ICEACE  0.9.9
Design Documentation of ICEACE Implementation on FLAME Multi-agent Simulation Platform
 All Data Structures Files Functions Variables Typedefs Macros Pages
/Users/bulent/Documents/AWorkspace/iceace/FLAME/main.c
Go to the documentation of this file.
1 
6 #include "header.h"
7 #define COMPACT_PRINTOUT_P_THRESHOLD 8
8 
14 int main(int argc, char * argv[])
15 {
16  /* Timing variables */
17  double start, stop, interval;
18  FILE *file;
19  char data[100];
20  char logfilepath[1000];
21  char inputpath[1000];
22  char * c;
23  int lastd = 0;
24  int i;
25  int rc;
26  int iteration_number = 0;
27  int iteration_total;
28  int * p_iteration_number = &iteration_number;
29  //xmachine_memory_firm * temp_xmachine_firm;
30  //xmachine_memory_household * temp_xmachine_household;
31  //xmachine_memory_equityfund * temp_xmachine_equityfund;
32  //xmachine_memory_bank * temp_xmachine_bank;
33  //xmachine_memory_government * temp_xmachine_government;
34  //xmachine_memory_centralbank * temp_xmachine_centralbank;
35  //xmachine_memory_jpoffice * temp_xmachine_jpoffice;
36  //xmachine_memory_mall * temp_xmachine_mall;
37  //xmachine_memory_reagency * temp_xmachine_reagency;
38 
39  int FLAME_firm_bank_update_deposit_message_board_write;
40  int FLAME_firm_bank_update_deposit_message_board_read;
41  int FLAME_household_bank_update_deposit_message_board_write;
42  int FLAME_household_bank_update_deposit_message_board_read;
43  int FLAME_interest_rate_message_board_write;
44  int FLAME_interest_rate_message_board_read;
45  int FLAME_tax_rate_message_board_write;
46  int FLAME_tax_rate_message_board_read;
47  int FLAME_buy_message_board_write;
48  int FLAME_buy_message_board_read;
49  int FLAME_bought_message_board_write;
50  int FLAME_bought_message_board_read;
51  int FLAME_sell_message_board_write;
52  int FLAME_sell_message_board_read;
53  int FLAME_sold_message_board_write;
54  int FLAME_sold_message_board_read;
55  int FLAME_goods_transactions_summary_message_board_write;
56  int FLAME_goods_transactions_summary_message_board_read;
57  int FLAME_fired_message_board_write;
58  int FLAME_fired_message_board_read;
59  int FLAME_vacancy_stage1_message_board_write;
60  int FLAME_vacancy_stage1_message_board_read;
61  int FLAME_job_application_stage2_message_board_write;
62  int FLAME_job_application_stage2_message_board_read;
63  int FLAME_job_application_stage1_message_board_write;
64  int FLAME_job_application_stage1_message_board_read;
65  int FLAME_job_match_stage1_message_board_write;
66  int FLAME_job_match_stage1_message_board_read;
67  int FLAME_job_change_message_board_write;
68  int FLAME_job_change_message_board_read;
69  int FLAME_vacancy_stage2_message_board_write;
70  int FLAME_vacancy_stage2_message_board_read;
71  int FLAME_job_match_stage2_message_board_write;
72  int FLAME_job_match_stage2_message_board_read;
73  int FLAME_employment_status_message_board_write;
74  int FLAME_employment_status_message_board_read;
75  int FLAME_loan_request_1_message_board_write;
76  int FLAME_loan_request_1_message_board_read;
77  int FLAME_loan_request_2_message_board_write;
78  int FLAME_loan_request_2_message_board_read;
79  int FLAME_loan_acknowledge_1_message_board_write;
80  int FLAME_loan_acknowledge_1_message_board_read;
81  int FLAME_loan_acknowledge_2_message_board_write;
82  int FLAME_loan_acknowledge_2_message_board_read;
83  int FLAME_debt_request_message_board_write;
84  int FLAME_debt_request_message_board_read;
85  int FLAME_household_share_message_board_write;
86  int FLAME_household_share_message_board_read;
87  int FLAME_capital_tax_message_board_write;
88  int FLAME_capital_tax_message_board_read;
89  int FLAME_labour_tax_message_board_write;
90  int FLAME_labour_tax_message_board_read;
91  int FLAME_unemployment_benefit_message_board_write;
92  int FLAME_unemployment_benefit_message_board_read;
93  int FLAME_general_benefit_message_board_write;
94  int FLAME_general_benefit_message_board_read;
95  int FLAME_fund_request_message_board_write;
96  int FLAME_fund_request_message_board_read;
97  int FLAME_fund_request_ack_message_board_write;
98  int FLAME_fund_request_ack_message_board_read;
99  int FLAME_new_entrant_loan_message_board_write;
100  int FLAME_new_entrant_loan_message_board_read;
101  int FLAME_interest_on_loan_message_board_write;
102  int FLAME_interest_on_loan_message_board_read;
103  int FLAME_loan_writeoff_message_board_write;
104  int FLAME_loan_writeoff_message_board_read;
105  int FLAME_firm_net_profit_message_board_write;
106  int FLAME_firm_net_profit_message_board_read;
107  int FLAME_bank_net_profit_message_board_write;
108  int FLAME_bank_net_profit_message_board_read;
109  int FLAME_bank_centralbank_interest_payment_message_board_write;
110  int FLAME_bank_centralbank_interest_payment_message_board_read;
111  int FLAME_bank_centralbank_debt_payment_message_board_write;
112  int FLAME_bank_centralbank_debt_payment_message_board_read;
113  int FLAME_centralbank_government_profit_message_board_write;
114  int FLAME_centralbank_government_profit_message_board_read;
115  int FLAME_housing_price_message_board_write;
116  int FLAME_housing_price_message_board_read;
117  int FLAME_buy_housing_message_board_write;
118  int FLAME_buy_housing_message_board_read;
119  int FLAME_sell_housing_message_board_write;
120  int FLAME_sell_housing_message_board_read;
121  int FLAME_bought_housing_message_board_write;
122  int FLAME_bought_housing_message_board_read;
123  int FLAME_sold_housing_message_board_write;
124  int FLAME_sold_housing_message_board_read;
125  int FLAME_mortgaging_capacity_message_board_write;
126  int FLAME_mortgaging_capacity_message_board_read;
127  int FLAME_mortgage_requests_message_board_write;
128  int FLAME_mortgage_requests_message_board_read;
129  int FLAME_mortgage_payment_from_sale_message_board_write;
130  int FLAME_mortgage_payment_from_sale_message_board_read;
131  int FLAME_mortgage_payment_message_board_write;
132  int FLAME_mortgage_payment_message_board_read;
133  int FLAME_mortgage_writeoff_message_board_write;
134  int FLAME_mortgage_writeoff_message_board_read;
135  int FLAME_housing_transactions_summary_message_board_write;
136  int FLAME_housing_transactions_summary_message_board_read;
137 
138  /* Particle cloud data */
139  double cloud_data[6] = {0.0,0.0,0.0,0.0,0.0,0.0};
140  /* Count to debug function branches */
141  int FLAME_debug_count;
142 
143 /* For partition method. Makes geometric (-g flag) the default but may be overridden with -r for round-robin */
144  int partition_method=1;
145 
146 
147 
148  /* Output frequency is 1 as default */
149  output_frequency = 1;
150  /* Set random seed */
151 /* srand(time(NULL)); */
152 
153 
154 
155  rc = MB_Env_Init();
156  #ifdef ERRCHECK
157  if (rc != MB_SUCCESS)
158  {
159  fprintf(stderr, "ERROR: Failed to initialise Message Board environment\n");
160  switch(rc) {
161  case MB_ERR_MPI:
162  fprintf(stderr, "\t reason: MPI library not initialised\n");
163  break;
164  case MB_ERR_MEMALLOC:
165  fprintf(stderr, "\t reason: out of memory\n");
166  break;
167  default:
168  fprintf(stderr, "\t MB_Env_Init returned error code: %d (see libmboard docs for details)\n", rc);
169  break;
170  }
171 
172 
173  exit(rc);
174 
175  }
176  #endif
177 
178  /* For backwards compatabilty allocate current_xmachine */
179  current_xmachine = (xmachine *)malloc(sizeof(xmachine));
180  if(current_xmachine == NULL) {printf("**** ERROR in Memory check current_xmachine\n");exit(EXIT_FAILURE);}
181  /*CHECK_POINTER(current_xmachine);*/
182 
183  /* Initialise pointers */
184  initialise_pointers();
185 
186 
187  printf("FLAME Application: ICEACE \n");
188 
189 
190  printf("Debug mode enabled \n");
191 FLAME_debug_count = 0;
192 /* Use to stop compiler warnings if not used */
193 if(FLAME_debug_count == 0) {}
194 
195 
196 
197 
198 if(argc < 2)
199  {
200 
201  printf("Usage: %s <number of iterations> [<states_directory>]/<init_state> <partitions> [-f # | -f #+#]\n",argv[0]);
202  printf("\t-f\tOutput frequency, 1st # is frequency, 2nd # is the offset if required\n");
203 
204 
205 
206  exit(0);
207  }
208  iteration_total = atoi(argv[1]);
209 printf("Iterations: %i\n", iteration_total);
210 
211  /* Read initial states of x-machines */
212  if(argc < 3)
213  {
214  printf("Need two parameters\n");
215  exit(0);
216  }
217  strcpy(inputpath, argv[2]);
218 /*printf("Initial states: %s\n", inputpath);*/
219 
220  i = 0;
221  lastd = -1;
222  while(inputpath[i] != '\0')
223  {
224  /* For windows directories */
225  if(inputpath[i] == '\\') lastd=i;
226  /* For unix directories */
227  if(inputpath[i] == '/') lastd=i;
228  i++;
229  }
230  strcpy(outputpath, inputpath);
231  outputpath[lastd+1] = '\0';
232 
233 /*printf("Ouput dir: %s\n", outputpath);*/
234 
235 
236  /* Read number of space partitions (1 by default) */
237  totalnodes = 1;
238  if(argc > 3)
239  {
240  totalnodes = atoi(argv[3]);
241  }
242 
243 
244  i = 3;
245  while(argc > i)
246  {
247  if(strcmp(argv[i],"-f") == 0)
248  {
249  if(argc > (i+1))
250  {
251  output_offset = 0;
252  /* Find offset, separated by the char '+' */
253  c = strchr(argv[(i+1)], '+');
254  if(c == NULL)
255  {
256  output_frequency = atoi(argv[(i+1)]);
257  printf("Using output frequency of: %d\n", output_frequency);
258  }
259  else
260  {
261  output_offset = atoi(argv[(i+1)]+(c-argv[(i+1)])+1);
262  argv[(i+1)][c-argv[(i+1)]] = '\0';
263  output_frequency = atoi(argv[(i+1)]);
264  printf("Using output frequency of: %d with offset %d\n", output_frequency, output_offset);
265  }
266 
267  if(output_frequency == 0)
268  {
269  printf("Output frequency cannot be zero\n");
270  exit(0);
271  }
272 
273  i++;
274  }
275  else
276  {
277  printf("Output frequency number not defined\n");
278  exit(0);
279  }
280  }
281  /* Partitioning method: -g = geometric, -r = round-robin */
282  if(strcmp(argv[i],"-g") == 0) partition_method = 1;
283  if(strcmp(argv[i],"-r") == 0) partition_method = 2;
284  i++;
285  }
286 
287 
288  /* Read initial data into p_xmachine */
289 
290  //agent_list = p_xmachine;
291  readinitialstates(inputpath, outputpath, p_iteration_number, cloud_data, partition_method, 0);
292  /* Generate partitions */
293  generate_partitions(cloud_data,totalnodes,partition_method);
294  save_partition_data();
295 
296 
297 
298 
299 
300  /* Partition data */
301  /* stc: no partitions in serial */
302  //partition_data(totalnodes, agent_list, cloud_data, partition_method);
303 
304 
305 
306 /* Use MB_IndexMap routines from libmboard v0.2 */
307 /* For each agent constant (that is used in a filter(?))
308  * declare an index map handle */
309 
310 
311 
312  /*i = 0;
313  current_node = *p_node_info;
314  while(current_node)
315  {
316  printf("No of agents on partition %d: %d\n", current_node->node_id, current_node->agent_total);
317  i += current_node->agent_total;
318  current_node = current_node->next;
319  }
320  printf("Agent total check: %d\n", i);*/
321 
322  /* restore current_node pointer */
323  //current_node = *p_node_info;
324 
325 
326 
327  /* Start log file (now so that xvisualiser can read straight away) */
328 
329  /* Write log file */
330  sprintf(logfilepath, "%slog.xml", outputpath);
331  if((file = fopen(logfilepath, "w"))==NULL)
332  {
333  printf("Error: cannot open file '%s' for writing\n", logfilepath);
334  exit(0);
335  }
336  (void)fputs("<model_run>\n", file);
337  (void)fputs("<codetype>", file);
338  (void)fputs("serial", file);
339 
340  (void)fputs("</codetype>\n", file);
341  (void)fputs("<nodes>", file);
342  sprintf(data, "%i", totalnodes);
343  (void)fputs(data, file);
344  (void)fputs("</nodes>\n", file);
345 
346  /* print timer into */
347  (void)fputs("<!-- <time> unit: milliseconds -->\n", file);
348 
349  sprintf(data, "unspecified");
350 
351  (void)fputs("<!-- <time> timer resolution: ", file);
352  (void)fputs(data, file);
353  (void)fputs(")-->\n", file);
354 
355  start = get_time();
356  stop = get_time();
357  sprintf(data, "%.2e ms", (stop - start) * 1000.0);
358  (void)fputs("<!-- <time> timer overhead: ~", file);
359  (void)fputs(data, file);
360  (void)fputs(")-->\n", file);
361 
362 
363  (void)fclose(file);
364 
365 
366  /* For each message check if their exists agents that input/output the message */
367  FLAME_firm_bank_update_deposit_message_board_write = 0;
368  FLAME_firm_bank_update_deposit_message_board_read = 0;
369  /* Sending agents */
370  if(firm_start_state->agents != NULL) FLAME_firm_bank_update_deposit_message_board_write = 1;
371 
372  /* Reading agents */
373  if(bank_start_state->agents != NULL) FLAME_firm_bank_update_deposit_message_board_read = 1;
374 
375  /* Call message board library with details */
376  if(FLAME_firm_bank_update_deposit_message_board_write == 0 &&
377  FLAME_firm_bank_update_deposit_message_board_read == 0)
378  rc = MB_SetAccessMode(b_firm_bank_update_deposit, MB_MODE_IDLE);
379  if(FLAME_firm_bank_update_deposit_message_board_write == 1 &&
380  FLAME_firm_bank_update_deposit_message_board_read == 0)
381  rc = MB_SetAccessMode(b_firm_bank_update_deposit, MB_MODE_WRITEONLY);
382  if(FLAME_firm_bank_update_deposit_message_board_write == 0 &&
383  FLAME_firm_bank_update_deposit_message_board_read == 1)
384  rc = MB_SetAccessMode(b_firm_bank_update_deposit, MB_MODE_READONLY);
385  if(FLAME_firm_bank_update_deposit_message_board_write == 1 &&
386  FLAME_firm_bank_update_deposit_message_board_read == 1)
387  rc = MB_SetAccessMode(b_firm_bank_update_deposit, MB_MODE_READWRITE);
388  #ifdef ERRCHECK
389  if (rc != MB_SUCCESS)
390  {
391  fprintf(stderr, "ERROR: Could not set access mode of 'firm_bank_update_deposit' board\n");
392  switch(rc) {
393  case MB_ERR_INVALID:
394  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is invalid\n");
395  break;
396  case MB_ERR_LOCKED:
397  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is locked\n");
398  break;
399  case MB_ERR_MEMALLOC:
400  fprintf(stderr, "\t reason: out of memory\n");
401  break;
402  case MB_ERR_INTERNAL:
403  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
404  break;
405  default:
406  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
407  break;
408  }
409 
410  exit(rc);
411  }
412  #endif
413  FLAME_household_bank_update_deposit_message_board_write = 0;
414  FLAME_household_bank_update_deposit_message_board_read = 0;
415  /* Sending agents */
416  if(household_start_state->agents != NULL) FLAME_household_bank_update_deposit_message_board_write = 1;
417 
418  /* Reading agents */
419  if(bank_start_state->agents != NULL) FLAME_household_bank_update_deposit_message_board_read = 1;
420 
421  /* Call message board library with details */
422  if(FLAME_household_bank_update_deposit_message_board_write == 0 &&
423  FLAME_household_bank_update_deposit_message_board_read == 0)
424  rc = MB_SetAccessMode(b_household_bank_update_deposit, MB_MODE_IDLE);
425  if(FLAME_household_bank_update_deposit_message_board_write == 1 &&
426  FLAME_household_bank_update_deposit_message_board_read == 0)
427  rc = MB_SetAccessMode(b_household_bank_update_deposit, MB_MODE_WRITEONLY);
428  if(FLAME_household_bank_update_deposit_message_board_write == 0 &&
429  FLAME_household_bank_update_deposit_message_board_read == 1)
430  rc = MB_SetAccessMode(b_household_bank_update_deposit, MB_MODE_READONLY);
431  if(FLAME_household_bank_update_deposit_message_board_write == 1 &&
432  FLAME_household_bank_update_deposit_message_board_read == 1)
433  rc = MB_SetAccessMode(b_household_bank_update_deposit, MB_MODE_READWRITE);
434  #ifdef ERRCHECK
435  if (rc != MB_SUCCESS)
436  {
437  fprintf(stderr, "ERROR: Could not set access mode of 'household_bank_update_deposit' board\n");
438  switch(rc) {
439  case MB_ERR_INVALID:
440  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is invalid\n");
441  break;
442  case MB_ERR_LOCKED:
443  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is locked\n");
444  break;
445  case MB_ERR_MEMALLOC:
446  fprintf(stderr, "\t reason: out of memory\n");
447  break;
448  case MB_ERR_INTERNAL:
449  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
450  break;
451  default:
452  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
453  break;
454  }
455 
456  exit(rc);
457  }
458  #endif
459  FLAME_interest_rate_message_board_write = 0;
460  FLAME_interest_rate_message_board_read = 0;
461  /* Sending agents */
462  if(centralbank_start_state->agents != NULL) FLAME_interest_rate_message_board_write = 1;
463 
464  /* Reading agents */
465  if(firm_start_state->agents != NULL) FLAME_interest_rate_message_board_read = 1;
466  if(household_start_state->agents != NULL) FLAME_interest_rate_message_board_read = 1;
467  if(bank_start_state->agents != NULL) FLAME_interest_rate_message_board_read = 1;
468  if(reagency_start_state->agents != NULL) FLAME_interest_rate_message_board_read = 1;
469 
470  /* Call message board library with details */
471  if(FLAME_interest_rate_message_board_write == 0 &&
472  FLAME_interest_rate_message_board_read == 0)
473  rc = MB_SetAccessMode(b_interest_rate, MB_MODE_IDLE);
474  if(FLAME_interest_rate_message_board_write == 1 &&
475  FLAME_interest_rate_message_board_read == 0)
476  rc = MB_SetAccessMode(b_interest_rate, MB_MODE_WRITEONLY);
477  if(FLAME_interest_rate_message_board_write == 0 &&
478  FLAME_interest_rate_message_board_read == 1)
479  rc = MB_SetAccessMode(b_interest_rate, MB_MODE_READONLY);
480  if(FLAME_interest_rate_message_board_write == 1 &&
481  FLAME_interest_rate_message_board_read == 1)
482  rc = MB_SetAccessMode(b_interest_rate, MB_MODE_READWRITE);
483  #ifdef ERRCHECK
484  if (rc != MB_SUCCESS)
485  {
486  fprintf(stderr, "ERROR: Could not set access mode of 'interest_rate' board\n");
487  switch(rc) {
488  case MB_ERR_INVALID:
489  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
490  break;
491  case MB_ERR_LOCKED:
492  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
493  break;
494  case MB_ERR_MEMALLOC:
495  fprintf(stderr, "\t reason: out of memory\n");
496  break;
497  case MB_ERR_INTERNAL:
498  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
499  break;
500  default:
501  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
502  break;
503  }
504 
505  exit(rc);
506  }
507  #endif
508  FLAME_tax_rate_message_board_write = 0;
509  FLAME_tax_rate_message_board_read = 0;
510  /* Sending agents */
511  if(government_start_state->agents != NULL) FLAME_tax_rate_message_board_write = 1;
512 
513  /* Reading agents */
514  if(firm_start_state->agents != NULL) FLAME_tax_rate_message_board_read = 1;
515  if(household_start_state->agents != NULL) FLAME_tax_rate_message_board_read = 1;
516  if(equityfund_start_state->agents != NULL) FLAME_tax_rate_message_board_read = 1;
517 
518  /* Call message board library with details */
519  if(FLAME_tax_rate_message_board_write == 0 &&
520  FLAME_tax_rate_message_board_read == 0)
521  rc = MB_SetAccessMode(b_tax_rate, MB_MODE_IDLE);
522  if(FLAME_tax_rate_message_board_write == 1 &&
523  FLAME_tax_rate_message_board_read == 0)
524  rc = MB_SetAccessMode(b_tax_rate, MB_MODE_WRITEONLY);
525  if(FLAME_tax_rate_message_board_write == 0 &&
526  FLAME_tax_rate_message_board_read == 1)
527  rc = MB_SetAccessMode(b_tax_rate, MB_MODE_READONLY);
528  if(FLAME_tax_rate_message_board_write == 1 &&
529  FLAME_tax_rate_message_board_read == 1)
530  rc = MB_SetAccessMode(b_tax_rate, MB_MODE_READWRITE);
531  #ifdef ERRCHECK
532  if (rc != MB_SUCCESS)
533  {
534  fprintf(stderr, "ERROR: Could not set access mode of 'tax_rate' board\n");
535  switch(rc) {
536  case MB_ERR_INVALID:
537  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
538  break;
539  case MB_ERR_LOCKED:
540  fprintf(stderr, "\t reason: 'tax_rate' board is locked\n");
541  break;
542  case MB_ERR_MEMALLOC:
543  fprintf(stderr, "\t reason: out of memory\n");
544  break;
545  case MB_ERR_INTERNAL:
546  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
547  break;
548  default:
549  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
550  break;
551  }
552 
553  exit(rc);
554  }
555  #endif
556  FLAME_buy_message_board_write = 0;
557  FLAME_buy_message_board_read = 0;
558  /* Sending agents */
559  if(household_start_state->agents != NULL) FLAME_buy_message_board_write = 1;
560 
561  /* Reading agents */
562  if(mall_start_state->agents != NULL) FLAME_buy_message_board_read = 1;
563 
564  /* Call message board library with details */
565  if(FLAME_buy_message_board_write == 0 &&
566  FLAME_buy_message_board_read == 0)
567  rc = MB_SetAccessMode(b_buy, MB_MODE_IDLE);
568  if(FLAME_buy_message_board_write == 1 &&
569  FLAME_buy_message_board_read == 0)
570  rc = MB_SetAccessMode(b_buy, MB_MODE_WRITEONLY);
571  if(FLAME_buy_message_board_write == 0 &&
572  FLAME_buy_message_board_read == 1)
573  rc = MB_SetAccessMode(b_buy, MB_MODE_READONLY);
574  if(FLAME_buy_message_board_write == 1 &&
575  FLAME_buy_message_board_read == 1)
576  rc = MB_SetAccessMode(b_buy, MB_MODE_READWRITE);
577  #ifdef ERRCHECK
578  if (rc != MB_SUCCESS)
579  {
580  fprintf(stderr, "ERROR: Could not set access mode of 'buy' board\n");
581  switch(rc) {
582  case MB_ERR_INVALID:
583  fprintf(stderr, "\t reason: 'buy' board is invalid\n");
584  break;
585  case MB_ERR_LOCKED:
586  fprintf(stderr, "\t reason: 'buy' board is locked\n");
587  break;
588  case MB_ERR_MEMALLOC:
589  fprintf(stderr, "\t reason: out of memory\n");
590  break;
591  case MB_ERR_INTERNAL:
592  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
593  break;
594  default:
595  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
596  break;
597  }
598 
599  exit(rc);
600  }
601  #endif
602  FLAME_bought_message_board_write = 0;
603  FLAME_bought_message_board_read = 0;
604  /* Sending agents */
605  if(mall_start_state->agents != NULL) FLAME_bought_message_board_write = 1;
606 
607  /* Reading agents */
608  if(household_start_state->agents != NULL) FLAME_bought_message_board_read = 1;
609 
610  /* Call message board library with details */
611  if(FLAME_bought_message_board_write == 0 &&
612  FLAME_bought_message_board_read == 0)
613  rc = MB_SetAccessMode(b_bought, MB_MODE_IDLE);
614  if(FLAME_bought_message_board_write == 1 &&
615  FLAME_bought_message_board_read == 0)
616  rc = MB_SetAccessMode(b_bought, MB_MODE_WRITEONLY);
617  if(FLAME_bought_message_board_write == 0 &&
618  FLAME_bought_message_board_read == 1)
619  rc = MB_SetAccessMode(b_bought, MB_MODE_READONLY);
620  if(FLAME_bought_message_board_write == 1 &&
621  FLAME_bought_message_board_read == 1)
622  rc = MB_SetAccessMode(b_bought, MB_MODE_READWRITE);
623  #ifdef ERRCHECK
624  if (rc != MB_SUCCESS)
625  {
626  fprintf(stderr, "ERROR: Could not set access mode of 'bought' board\n");
627  switch(rc) {
628  case MB_ERR_INVALID:
629  fprintf(stderr, "\t reason: 'bought' board is invalid\n");
630  break;
631  case MB_ERR_LOCKED:
632  fprintf(stderr, "\t reason: 'bought' board is locked\n");
633  break;
634  case MB_ERR_MEMALLOC:
635  fprintf(stderr, "\t reason: out of memory\n");
636  break;
637  case MB_ERR_INTERNAL:
638  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
639  break;
640  default:
641  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
642  break;
643  }
644 
645  exit(rc);
646  }
647  #endif
648  FLAME_sell_message_board_write = 0;
649  FLAME_sell_message_board_read = 0;
650  /* Sending agents */
651  if(firm_start_state->agents != NULL) FLAME_sell_message_board_write = 1;
652 
653  /* Reading agents */
654  if(mall_start_state->agents != NULL) FLAME_sell_message_board_read = 1;
655 
656  /* Call message board library with details */
657  if(FLAME_sell_message_board_write == 0 &&
658  FLAME_sell_message_board_read == 0)
659  rc = MB_SetAccessMode(b_sell, MB_MODE_IDLE);
660  if(FLAME_sell_message_board_write == 1 &&
661  FLAME_sell_message_board_read == 0)
662  rc = MB_SetAccessMode(b_sell, MB_MODE_WRITEONLY);
663  if(FLAME_sell_message_board_write == 0 &&
664  FLAME_sell_message_board_read == 1)
665  rc = MB_SetAccessMode(b_sell, MB_MODE_READONLY);
666  if(FLAME_sell_message_board_write == 1 &&
667  FLAME_sell_message_board_read == 1)
668  rc = MB_SetAccessMode(b_sell, MB_MODE_READWRITE);
669  #ifdef ERRCHECK
670  if (rc != MB_SUCCESS)
671  {
672  fprintf(stderr, "ERROR: Could not set access mode of 'sell' board\n");
673  switch(rc) {
674  case MB_ERR_INVALID:
675  fprintf(stderr, "\t reason: 'sell' board is invalid\n");
676  break;
677  case MB_ERR_LOCKED:
678  fprintf(stderr, "\t reason: 'sell' board is locked\n");
679  break;
680  case MB_ERR_MEMALLOC:
681  fprintf(stderr, "\t reason: out of memory\n");
682  break;
683  case MB_ERR_INTERNAL:
684  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
685  break;
686  default:
687  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
688  break;
689  }
690 
691  exit(rc);
692  }
693  #endif
694  FLAME_sold_message_board_write = 0;
695  FLAME_sold_message_board_read = 0;
696  /* Sending agents */
697  if(mall_start_state->agents != NULL) FLAME_sold_message_board_write = 1;
698 
699  /* Reading agents */
700  if(firm_start_state->agents != NULL) FLAME_sold_message_board_read = 1;
701 
702  /* Call message board library with details */
703  if(FLAME_sold_message_board_write == 0 &&
704  FLAME_sold_message_board_read == 0)
705  rc = MB_SetAccessMode(b_sold, MB_MODE_IDLE);
706  if(FLAME_sold_message_board_write == 1 &&
707  FLAME_sold_message_board_read == 0)
708  rc = MB_SetAccessMode(b_sold, MB_MODE_WRITEONLY);
709  if(FLAME_sold_message_board_write == 0 &&
710  FLAME_sold_message_board_read == 1)
711  rc = MB_SetAccessMode(b_sold, MB_MODE_READONLY);
712  if(FLAME_sold_message_board_write == 1 &&
713  FLAME_sold_message_board_read == 1)
714  rc = MB_SetAccessMode(b_sold, MB_MODE_READWRITE);
715  #ifdef ERRCHECK
716  if (rc != MB_SUCCESS)
717  {
718  fprintf(stderr, "ERROR: Could not set access mode of 'sold' board\n");
719  switch(rc) {
720  case MB_ERR_INVALID:
721  fprintf(stderr, "\t reason: 'sold' board is invalid\n");
722  break;
723  case MB_ERR_LOCKED:
724  fprintf(stderr, "\t reason: 'sold' board is locked\n");
725  break;
726  case MB_ERR_MEMALLOC:
727  fprintf(stderr, "\t reason: out of memory\n");
728  break;
729  case MB_ERR_INTERNAL:
730  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
731  break;
732  default:
733  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
734  break;
735  }
736 
737  exit(rc);
738  }
739  #endif
740  FLAME_goods_transactions_summary_message_board_write = 0;
741  FLAME_goods_transactions_summary_message_board_read = 0;
742  /* Sending agents */
743  if(mall_start_state->agents != NULL) FLAME_goods_transactions_summary_message_board_write = 1;
744 
745  /* Reading agents */
746  if(firm_start_state->agents != NULL) FLAME_goods_transactions_summary_message_board_read = 1;
747  if(centralbank_start_state->agents != NULL) FLAME_goods_transactions_summary_message_board_read = 1;
748 
749  /* Call message board library with details */
750  if(FLAME_goods_transactions_summary_message_board_write == 0 &&
751  FLAME_goods_transactions_summary_message_board_read == 0)
752  rc = MB_SetAccessMode(b_goods_transactions_summary, MB_MODE_IDLE);
753  if(FLAME_goods_transactions_summary_message_board_write == 1 &&
754  FLAME_goods_transactions_summary_message_board_read == 0)
755  rc = MB_SetAccessMode(b_goods_transactions_summary, MB_MODE_WRITEONLY);
756  if(FLAME_goods_transactions_summary_message_board_write == 0 &&
757  FLAME_goods_transactions_summary_message_board_read == 1)
758  rc = MB_SetAccessMode(b_goods_transactions_summary, MB_MODE_READONLY);
759  if(FLAME_goods_transactions_summary_message_board_write == 1 &&
760  FLAME_goods_transactions_summary_message_board_read == 1)
761  rc = MB_SetAccessMode(b_goods_transactions_summary, MB_MODE_READWRITE);
762  #ifdef ERRCHECK
763  if (rc != MB_SUCCESS)
764  {
765  fprintf(stderr, "ERROR: Could not set access mode of 'goods_transactions_summary' board\n");
766  switch(rc) {
767  case MB_ERR_INVALID:
768  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
769  break;
770  case MB_ERR_LOCKED:
771  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is locked\n");
772  break;
773  case MB_ERR_MEMALLOC:
774  fprintf(stderr, "\t reason: out of memory\n");
775  break;
776  case MB_ERR_INTERNAL:
777  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
778  break;
779  default:
780  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
781  break;
782  }
783 
784  exit(rc);
785  }
786  #endif
787  FLAME_fired_message_board_write = 0;
788  FLAME_fired_message_board_read = 0;
789  /* Sending agents */
790  if(firm_start_state->agents != NULL) FLAME_fired_message_board_write = 1;
791 
792  /* Reading agents */
793  if(household_start_state->agents != NULL) FLAME_fired_message_board_read = 1;
794 
795  /* Call message board library with details */
796  if(FLAME_fired_message_board_write == 0 &&
797  FLAME_fired_message_board_read == 0)
798  rc = MB_SetAccessMode(b_fired, MB_MODE_IDLE);
799  if(FLAME_fired_message_board_write == 1 &&
800  FLAME_fired_message_board_read == 0)
801  rc = MB_SetAccessMode(b_fired, MB_MODE_WRITEONLY);
802  if(FLAME_fired_message_board_write == 0 &&
803  FLAME_fired_message_board_read == 1)
804  rc = MB_SetAccessMode(b_fired, MB_MODE_READONLY);
805  if(FLAME_fired_message_board_write == 1 &&
806  FLAME_fired_message_board_read == 1)
807  rc = MB_SetAccessMode(b_fired, MB_MODE_READWRITE);
808  #ifdef ERRCHECK
809  if (rc != MB_SUCCESS)
810  {
811  fprintf(stderr, "ERROR: Could not set access mode of 'fired' board\n");
812  switch(rc) {
813  case MB_ERR_INVALID:
814  fprintf(stderr, "\t reason: 'fired' board is invalid\n");
815  break;
816  case MB_ERR_LOCKED:
817  fprintf(stderr, "\t reason: 'fired' board is locked\n");
818  break;
819  case MB_ERR_MEMALLOC:
820  fprintf(stderr, "\t reason: out of memory\n");
821  break;
822  case MB_ERR_INTERNAL:
823  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
824  break;
825  default:
826  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
827  break;
828  }
829 
830  exit(rc);
831  }
832  #endif
833  FLAME_vacancy_stage1_message_board_write = 0;
834  FLAME_vacancy_stage1_message_board_read = 0;
835  /* Sending agents */
836  if(firm_start_state->agents != NULL) FLAME_vacancy_stage1_message_board_write = 1;
837 
838  /* Reading agents */
839  if(jpoffice_start_state->agents != NULL) FLAME_vacancy_stage1_message_board_read = 1;
840 
841  /* Call message board library with details */
842  if(FLAME_vacancy_stage1_message_board_write == 0 &&
843  FLAME_vacancy_stage1_message_board_read == 0)
844  rc = MB_SetAccessMode(b_vacancy_stage1, MB_MODE_IDLE);
845  if(FLAME_vacancy_stage1_message_board_write == 1 &&
846  FLAME_vacancy_stage1_message_board_read == 0)
847  rc = MB_SetAccessMode(b_vacancy_stage1, MB_MODE_WRITEONLY);
848  if(FLAME_vacancy_stage1_message_board_write == 0 &&
849  FLAME_vacancy_stage1_message_board_read == 1)
850  rc = MB_SetAccessMode(b_vacancy_stage1, MB_MODE_READONLY);
851  if(FLAME_vacancy_stage1_message_board_write == 1 &&
852  FLAME_vacancy_stage1_message_board_read == 1)
853  rc = MB_SetAccessMode(b_vacancy_stage1, MB_MODE_READWRITE);
854  #ifdef ERRCHECK
855  if (rc != MB_SUCCESS)
856  {
857  fprintf(stderr, "ERROR: Could not set access mode of 'vacancy_stage1' board\n");
858  switch(rc) {
859  case MB_ERR_INVALID:
860  fprintf(stderr, "\t reason: 'vacancy_stage1' board is invalid\n");
861  break;
862  case MB_ERR_LOCKED:
863  fprintf(stderr, "\t reason: 'vacancy_stage1' board is locked\n");
864  break;
865  case MB_ERR_MEMALLOC:
866  fprintf(stderr, "\t reason: out of memory\n");
867  break;
868  case MB_ERR_INTERNAL:
869  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
870  break;
871  default:
872  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
873  break;
874  }
875 
876  exit(rc);
877  }
878  #endif
879  FLAME_job_application_stage2_message_board_write = 0;
880  FLAME_job_application_stage2_message_board_read = 0;
881  /* Sending agents */
882  if(household_start_state->agents != NULL) FLAME_job_application_stage2_message_board_write = 1;
883 
884  /* Reading agents */
885  if(jpoffice_start_state->agents != NULL) FLAME_job_application_stage2_message_board_read = 1;
886 
887  /* Call message board library with details */
888  if(FLAME_job_application_stage2_message_board_write == 0 &&
889  FLAME_job_application_stage2_message_board_read == 0)
890  rc = MB_SetAccessMode(b_job_application_stage2, MB_MODE_IDLE);
891  if(FLAME_job_application_stage2_message_board_write == 1 &&
892  FLAME_job_application_stage2_message_board_read == 0)
893  rc = MB_SetAccessMode(b_job_application_stage2, MB_MODE_WRITEONLY);
894  if(FLAME_job_application_stage2_message_board_write == 0 &&
895  FLAME_job_application_stage2_message_board_read == 1)
896  rc = MB_SetAccessMode(b_job_application_stage2, MB_MODE_READONLY);
897  if(FLAME_job_application_stage2_message_board_write == 1 &&
898  FLAME_job_application_stage2_message_board_read == 1)
899  rc = MB_SetAccessMode(b_job_application_stage2, MB_MODE_READWRITE);
900  #ifdef ERRCHECK
901  if (rc != MB_SUCCESS)
902  {
903  fprintf(stderr, "ERROR: Could not set access mode of 'job_application_stage2' board\n");
904  switch(rc) {
905  case MB_ERR_INVALID:
906  fprintf(stderr, "\t reason: 'job_application_stage2' board is invalid\n");
907  break;
908  case MB_ERR_LOCKED:
909  fprintf(stderr, "\t reason: 'job_application_stage2' board is locked\n");
910  break;
911  case MB_ERR_MEMALLOC:
912  fprintf(stderr, "\t reason: out of memory\n");
913  break;
914  case MB_ERR_INTERNAL:
915  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
916  break;
917  default:
918  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
919  break;
920  }
921 
922  exit(rc);
923  }
924  #endif
925  FLAME_job_application_stage1_message_board_write = 0;
926  FLAME_job_application_stage1_message_board_read = 0;
927  /* Sending agents */
928  if(household_start_state->agents != NULL) FLAME_job_application_stage1_message_board_write = 1;
929 
930  /* Reading agents */
931  if(jpoffice_start_state->agents != NULL) FLAME_job_application_stage1_message_board_read = 1;
932 
933  /* Call message board library with details */
934  if(FLAME_job_application_stage1_message_board_write == 0 &&
935  FLAME_job_application_stage1_message_board_read == 0)
936  rc = MB_SetAccessMode(b_job_application_stage1, MB_MODE_IDLE);
937  if(FLAME_job_application_stage1_message_board_write == 1 &&
938  FLAME_job_application_stage1_message_board_read == 0)
939  rc = MB_SetAccessMode(b_job_application_stage1, MB_MODE_WRITEONLY);
940  if(FLAME_job_application_stage1_message_board_write == 0 &&
941  FLAME_job_application_stage1_message_board_read == 1)
942  rc = MB_SetAccessMode(b_job_application_stage1, MB_MODE_READONLY);
943  if(FLAME_job_application_stage1_message_board_write == 1 &&
944  FLAME_job_application_stage1_message_board_read == 1)
945  rc = MB_SetAccessMode(b_job_application_stage1, MB_MODE_READWRITE);
946  #ifdef ERRCHECK
947  if (rc != MB_SUCCESS)
948  {
949  fprintf(stderr, "ERROR: Could not set access mode of 'job_application_stage1' board\n");
950  switch(rc) {
951  case MB_ERR_INVALID:
952  fprintf(stderr, "\t reason: 'job_application_stage1' board is invalid\n");
953  break;
954  case MB_ERR_LOCKED:
955  fprintf(stderr, "\t reason: 'job_application_stage1' board is locked\n");
956  break;
957  case MB_ERR_MEMALLOC:
958  fprintf(stderr, "\t reason: out of memory\n");
959  break;
960  case MB_ERR_INTERNAL:
961  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
962  break;
963  default:
964  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
965  break;
966  }
967 
968  exit(rc);
969  }
970  #endif
971  FLAME_job_match_stage1_message_board_write = 0;
972  FLAME_job_match_stage1_message_board_read = 0;
973  /* Sending agents */
974  if(jpoffice_start_state->agents != NULL) FLAME_job_match_stage1_message_board_write = 1;
975 
976  /* Reading agents */
977  if(firm_start_state->agents != NULL) FLAME_job_match_stage1_message_board_read = 1;
978  if(household_start_state->agents != NULL) FLAME_job_match_stage1_message_board_read = 1;
979 
980  /* Call message board library with details */
981  if(FLAME_job_match_stage1_message_board_write == 0 &&
982  FLAME_job_match_stage1_message_board_read == 0)
983  rc = MB_SetAccessMode(b_job_match_stage1, MB_MODE_IDLE);
984  if(FLAME_job_match_stage1_message_board_write == 1 &&
985  FLAME_job_match_stage1_message_board_read == 0)
986  rc = MB_SetAccessMode(b_job_match_stage1, MB_MODE_WRITEONLY);
987  if(FLAME_job_match_stage1_message_board_write == 0 &&
988  FLAME_job_match_stage1_message_board_read == 1)
989  rc = MB_SetAccessMode(b_job_match_stage1, MB_MODE_READONLY);
990  if(FLAME_job_match_stage1_message_board_write == 1 &&
991  FLAME_job_match_stage1_message_board_read == 1)
992  rc = MB_SetAccessMode(b_job_match_stage1, MB_MODE_READWRITE);
993  #ifdef ERRCHECK
994  if (rc != MB_SUCCESS)
995  {
996  fprintf(stderr, "ERROR: Could not set access mode of 'job_match_stage1' board\n");
997  switch(rc) {
998  case MB_ERR_INVALID:
999  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
1000  break;
1001  case MB_ERR_LOCKED:
1002  fprintf(stderr, "\t reason: 'job_match_stage1' board is locked\n");
1003  break;
1004  case MB_ERR_MEMALLOC:
1005  fprintf(stderr, "\t reason: out of memory\n");
1006  break;
1007  case MB_ERR_INTERNAL:
1008  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1009  break;
1010  default:
1011  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1012  break;
1013  }
1014 
1015  exit(rc);
1016  }
1017  #endif
1018  FLAME_job_change_message_board_write = 0;
1019  FLAME_job_change_message_board_read = 0;
1020  /* Sending agents */
1021  if(household_start_state->agents != NULL) FLAME_job_change_message_board_write = 1;
1022 
1023  /* Reading agents */
1024  if(firm_start_state->agents != NULL) FLAME_job_change_message_board_read = 1;
1025 
1026  /* Call message board library with details */
1027  if(FLAME_job_change_message_board_write == 0 &&
1028  FLAME_job_change_message_board_read == 0)
1029  rc = MB_SetAccessMode(b_job_change, MB_MODE_IDLE);
1030  if(FLAME_job_change_message_board_write == 1 &&
1031  FLAME_job_change_message_board_read == 0)
1032  rc = MB_SetAccessMode(b_job_change, MB_MODE_WRITEONLY);
1033  if(FLAME_job_change_message_board_write == 0 &&
1034  FLAME_job_change_message_board_read == 1)
1035  rc = MB_SetAccessMode(b_job_change, MB_MODE_READONLY);
1036  if(FLAME_job_change_message_board_write == 1 &&
1037  FLAME_job_change_message_board_read == 1)
1038  rc = MB_SetAccessMode(b_job_change, MB_MODE_READWRITE);
1039  #ifdef ERRCHECK
1040  if (rc != MB_SUCCESS)
1041  {
1042  fprintf(stderr, "ERROR: Could not set access mode of 'job_change' board\n");
1043  switch(rc) {
1044  case MB_ERR_INVALID:
1045  fprintf(stderr, "\t reason: 'job_change' board is invalid\n");
1046  break;
1047  case MB_ERR_LOCKED:
1048  fprintf(stderr, "\t reason: 'job_change' board is locked\n");
1049  break;
1050  case MB_ERR_MEMALLOC:
1051  fprintf(stderr, "\t reason: out of memory\n");
1052  break;
1053  case MB_ERR_INTERNAL:
1054  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1055  break;
1056  default:
1057  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1058  break;
1059  }
1060 
1061  exit(rc);
1062  }
1063  #endif
1064  FLAME_vacancy_stage2_message_board_write = 0;
1065  FLAME_vacancy_stage2_message_board_read = 0;
1066  /* Sending agents */
1067  if(firm_start_state->agents != NULL) FLAME_vacancy_stage2_message_board_write = 1;
1068 
1069  /* Reading agents */
1070  if(jpoffice_start_state->agents != NULL) FLAME_vacancy_stage2_message_board_read = 1;
1071 
1072  /* Call message board library with details */
1073  if(FLAME_vacancy_stage2_message_board_write == 0 &&
1074  FLAME_vacancy_stage2_message_board_read == 0)
1075  rc = MB_SetAccessMode(b_vacancy_stage2, MB_MODE_IDLE);
1076  if(FLAME_vacancy_stage2_message_board_write == 1 &&
1077  FLAME_vacancy_stage2_message_board_read == 0)
1078  rc = MB_SetAccessMode(b_vacancy_stage2, MB_MODE_WRITEONLY);
1079  if(FLAME_vacancy_stage2_message_board_write == 0 &&
1080  FLAME_vacancy_stage2_message_board_read == 1)
1081  rc = MB_SetAccessMode(b_vacancy_stage2, MB_MODE_READONLY);
1082  if(FLAME_vacancy_stage2_message_board_write == 1 &&
1083  FLAME_vacancy_stage2_message_board_read == 1)
1084  rc = MB_SetAccessMode(b_vacancy_stage2, MB_MODE_READWRITE);
1085  #ifdef ERRCHECK
1086  if (rc != MB_SUCCESS)
1087  {
1088  fprintf(stderr, "ERROR: Could not set access mode of 'vacancy_stage2' board\n");
1089  switch(rc) {
1090  case MB_ERR_INVALID:
1091  fprintf(stderr, "\t reason: 'vacancy_stage2' board is invalid\n");
1092  break;
1093  case MB_ERR_LOCKED:
1094  fprintf(stderr, "\t reason: 'vacancy_stage2' board is locked\n");
1095  break;
1096  case MB_ERR_MEMALLOC:
1097  fprintf(stderr, "\t reason: out of memory\n");
1098  break;
1099  case MB_ERR_INTERNAL:
1100  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1101  break;
1102  default:
1103  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1104  break;
1105  }
1106 
1107  exit(rc);
1108  }
1109  #endif
1110  FLAME_job_match_stage2_message_board_write = 0;
1111  FLAME_job_match_stage2_message_board_read = 0;
1112  /* Sending agents */
1113  if(jpoffice_start_state->agents != NULL) FLAME_job_match_stage2_message_board_write = 1;
1114 
1115  /* Reading agents */
1116  if(firm_start_state->agents != NULL) FLAME_job_match_stage2_message_board_read = 1;
1117  if(household_start_state->agents != NULL) FLAME_job_match_stage2_message_board_read = 1;
1118 
1119  /* Call message board library with details */
1120  if(FLAME_job_match_stage2_message_board_write == 0 &&
1121  FLAME_job_match_stage2_message_board_read == 0)
1122  rc = MB_SetAccessMode(b_job_match_stage2, MB_MODE_IDLE);
1123  if(FLAME_job_match_stage2_message_board_write == 1 &&
1124  FLAME_job_match_stage2_message_board_read == 0)
1125  rc = MB_SetAccessMode(b_job_match_stage2, MB_MODE_WRITEONLY);
1126  if(FLAME_job_match_stage2_message_board_write == 0 &&
1127  FLAME_job_match_stage2_message_board_read == 1)
1128  rc = MB_SetAccessMode(b_job_match_stage2, MB_MODE_READONLY);
1129  if(FLAME_job_match_stage2_message_board_write == 1 &&
1130  FLAME_job_match_stage2_message_board_read == 1)
1131  rc = MB_SetAccessMode(b_job_match_stage2, MB_MODE_READWRITE);
1132  #ifdef ERRCHECK
1133  if (rc != MB_SUCCESS)
1134  {
1135  fprintf(stderr, "ERROR: Could not set access mode of 'job_match_stage2' board\n");
1136  switch(rc) {
1137  case MB_ERR_INVALID:
1138  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
1139  break;
1140  case MB_ERR_LOCKED:
1141  fprintf(stderr, "\t reason: 'job_match_stage2' board is locked\n");
1142  break;
1143  case MB_ERR_MEMALLOC:
1144  fprintf(stderr, "\t reason: out of memory\n");
1145  break;
1146  case MB_ERR_INTERNAL:
1147  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1148  break;
1149  default:
1150  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1151  break;
1152  }
1153 
1154  exit(rc);
1155  }
1156  #endif
1157  FLAME_employment_status_message_board_write = 0;
1158  FLAME_employment_status_message_board_read = 0;
1159  /* Sending agents */
1160  if(household_start_state->agents != NULL) FLAME_employment_status_message_board_write = 1;
1161 
1162  /* Reading agents */
1163  if(equityfund_start_state->agents != NULL) FLAME_employment_status_message_board_read = 1;
1164  if(government_start_state->agents != NULL) FLAME_employment_status_message_board_read = 1;
1165  if(centralbank_start_state->agents != NULL) FLAME_employment_status_message_board_read = 1;
1166 
1167  /* Call message board library with details */
1168  if(FLAME_employment_status_message_board_write == 0 &&
1169  FLAME_employment_status_message_board_read == 0)
1170  rc = MB_SetAccessMode(b_employment_status, MB_MODE_IDLE);
1171  if(FLAME_employment_status_message_board_write == 1 &&
1172  FLAME_employment_status_message_board_read == 0)
1173  rc = MB_SetAccessMode(b_employment_status, MB_MODE_WRITEONLY);
1174  if(FLAME_employment_status_message_board_write == 0 &&
1175  FLAME_employment_status_message_board_read == 1)
1176  rc = MB_SetAccessMode(b_employment_status, MB_MODE_READONLY);
1177  if(FLAME_employment_status_message_board_write == 1 &&
1178  FLAME_employment_status_message_board_read == 1)
1179  rc = MB_SetAccessMode(b_employment_status, MB_MODE_READWRITE);
1180  #ifdef ERRCHECK
1181  if (rc != MB_SUCCESS)
1182  {
1183  fprintf(stderr, "ERROR: Could not set access mode of 'employment_status' board\n");
1184  switch(rc) {
1185  case MB_ERR_INVALID:
1186  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
1187  break;
1188  case MB_ERR_LOCKED:
1189  fprintf(stderr, "\t reason: 'employment_status' board is locked\n");
1190  break;
1191  case MB_ERR_MEMALLOC:
1192  fprintf(stderr, "\t reason: out of memory\n");
1193  break;
1194  case MB_ERR_INTERNAL:
1195  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1196  break;
1197  default:
1198  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1199  break;
1200  }
1201 
1202  exit(rc);
1203  }
1204  #endif
1205  FLAME_loan_request_1_message_board_write = 0;
1206  FLAME_loan_request_1_message_board_read = 0;
1207  /* Sending agents */
1208  if(firm_start_state->agents != NULL) FLAME_loan_request_1_message_board_write = 1;
1209 
1210  /* Reading agents */
1211  if(bank_start_state->agents != NULL) FLAME_loan_request_1_message_board_read = 1;
1212 
1213  /* Call message board library with details */
1214  if(FLAME_loan_request_1_message_board_write == 0 &&
1215  FLAME_loan_request_1_message_board_read == 0)
1216  rc = MB_SetAccessMode(b_loan_request_1, MB_MODE_IDLE);
1217  if(FLAME_loan_request_1_message_board_write == 1 &&
1218  FLAME_loan_request_1_message_board_read == 0)
1219  rc = MB_SetAccessMode(b_loan_request_1, MB_MODE_WRITEONLY);
1220  if(FLAME_loan_request_1_message_board_write == 0 &&
1221  FLAME_loan_request_1_message_board_read == 1)
1222  rc = MB_SetAccessMode(b_loan_request_1, MB_MODE_READONLY);
1223  if(FLAME_loan_request_1_message_board_write == 1 &&
1224  FLAME_loan_request_1_message_board_read == 1)
1225  rc = MB_SetAccessMode(b_loan_request_1, MB_MODE_READWRITE);
1226  #ifdef ERRCHECK
1227  if (rc != MB_SUCCESS)
1228  {
1229  fprintf(stderr, "ERROR: Could not set access mode of 'loan_request_1' board\n");
1230  switch(rc) {
1231  case MB_ERR_INVALID:
1232  fprintf(stderr, "\t reason: 'loan_request_1' board is invalid\n");
1233  break;
1234  case MB_ERR_LOCKED:
1235  fprintf(stderr, "\t reason: 'loan_request_1' board is locked\n");
1236  break;
1237  case MB_ERR_MEMALLOC:
1238  fprintf(stderr, "\t reason: out of memory\n");
1239  break;
1240  case MB_ERR_INTERNAL:
1241  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1242  break;
1243  default:
1244  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1245  break;
1246  }
1247 
1248  exit(rc);
1249  }
1250  #endif
1251  FLAME_loan_request_2_message_board_write = 0;
1252  FLAME_loan_request_2_message_board_read = 0;
1253  /* Sending agents */
1254  if(firm_start_state->agents != NULL) FLAME_loan_request_2_message_board_write = 1;
1255 
1256  /* Reading agents */
1257  if(bank_start_state->agents != NULL) FLAME_loan_request_2_message_board_read = 1;
1258 
1259  /* Call message board library with details */
1260  if(FLAME_loan_request_2_message_board_write == 0 &&
1261  FLAME_loan_request_2_message_board_read == 0)
1262  rc = MB_SetAccessMode(b_loan_request_2, MB_MODE_IDLE);
1263  if(FLAME_loan_request_2_message_board_write == 1 &&
1264  FLAME_loan_request_2_message_board_read == 0)
1265  rc = MB_SetAccessMode(b_loan_request_2, MB_MODE_WRITEONLY);
1266  if(FLAME_loan_request_2_message_board_write == 0 &&
1267  FLAME_loan_request_2_message_board_read == 1)
1268  rc = MB_SetAccessMode(b_loan_request_2, MB_MODE_READONLY);
1269  if(FLAME_loan_request_2_message_board_write == 1 &&
1270  FLAME_loan_request_2_message_board_read == 1)
1271  rc = MB_SetAccessMode(b_loan_request_2, MB_MODE_READWRITE);
1272  #ifdef ERRCHECK
1273  if (rc != MB_SUCCESS)
1274  {
1275  fprintf(stderr, "ERROR: Could not set access mode of 'loan_request_2' board\n");
1276  switch(rc) {
1277  case MB_ERR_INVALID:
1278  fprintf(stderr, "\t reason: 'loan_request_2' board is invalid\n");
1279  break;
1280  case MB_ERR_LOCKED:
1281  fprintf(stderr, "\t reason: 'loan_request_2' board is locked\n");
1282  break;
1283  case MB_ERR_MEMALLOC:
1284  fprintf(stderr, "\t reason: out of memory\n");
1285  break;
1286  case MB_ERR_INTERNAL:
1287  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1288  break;
1289  default:
1290  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1291  break;
1292  }
1293 
1294  exit(rc);
1295  }
1296  #endif
1297  FLAME_loan_acknowledge_1_message_board_write = 0;
1298  FLAME_loan_acknowledge_1_message_board_read = 0;
1299  /* Sending agents */
1300  if(bank_start_state->agents != NULL) FLAME_loan_acknowledge_1_message_board_write = 1;
1301 
1302  /* Reading agents */
1303  if(firm_start_state->agents != NULL) FLAME_loan_acknowledge_1_message_board_read = 1;
1304 
1305  /* Call message board library with details */
1306  if(FLAME_loan_acknowledge_1_message_board_write == 0 &&
1307  FLAME_loan_acknowledge_1_message_board_read == 0)
1308  rc = MB_SetAccessMode(b_loan_acknowledge_1, MB_MODE_IDLE);
1309  if(FLAME_loan_acknowledge_1_message_board_write == 1 &&
1310  FLAME_loan_acknowledge_1_message_board_read == 0)
1311  rc = MB_SetAccessMode(b_loan_acknowledge_1, MB_MODE_WRITEONLY);
1312  if(FLAME_loan_acknowledge_1_message_board_write == 0 &&
1313  FLAME_loan_acknowledge_1_message_board_read == 1)
1314  rc = MB_SetAccessMode(b_loan_acknowledge_1, MB_MODE_READONLY);
1315  if(FLAME_loan_acknowledge_1_message_board_write == 1 &&
1316  FLAME_loan_acknowledge_1_message_board_read == 1)
1317  rc = MB_SetAccessMode(b_loan_acknowledge_1, MB_MODE_READWRITE);
1318  #ifdef ERRCHECK
1319  if (rc != MB_SUCCESS)
1320  {
1321  fprintf(stderr, "ERROR: Could not set access mode of 'loan_acknowledge_1' board\n");
1322  switch(rc) {
1323  case MB_ERR_INVALID:
1324  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is invalid\n");
1325  break;
1326  case MB_ERR_LOCKED:
1327  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is locked\n");
1328  break;
1329  case MB_ERR_MEMALLOC:
1330  fprintf(stderr, "\t reason: out of memory\n");
1331  break;
1332  case MB_ERR_INTERNAL:
1333  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1334  break;
1335  default:
1336  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1337  break;
1338  }
1339 
1340  exit(rc);
1341  }
1342  #endif
1343  FLAME_loan_acknowledge_2_message_board_write = 0;
1344  FLAME_loan_acknowledge_2_message_board_read = 0;
1345  /* Sending agents */
1346  if(bank_start_state->agents != NULL) FLAME_loan_acknowledge_2_message_board_write = 1;
1347 
1348  /* Reading agents */
1349  if(firm_start_state->agents != NULL) FLAME_loan_acknowledge_2_message_board_read = 1;
1350 
1351  /* Call message board library with details */
1352  if(FLAME_loan_acknowledge_2_message_board_write == 0 &&
1353  FLAME_loan_acknowledge_2_message_board_read == 0)
1354  rc = MB_SetAccessMode(b_loan_acknowledge_2, MB_MODE_IDLE);
1355  if(FLAME_loan_acknowledge_2_message_board_write == 1 &&
1356  FLAME_loan_acknowledge_2_message_board_read == 0)
1357  rc = MB_SetAccessMode(b_loan_acknowledge_2, MB_MODE_WRITEONLY);
1358  if(FLAME_loan_acknowledge_2_message_board_write == 0 &&
1359  FLAME_loan_acknowledge_2_message_board_read == 1)
1360  rc = MB_SetAccessMode(b_loan_acknowledge_2, MB_MODE_READONLY);
1361  if(FLAME_loan_acknowledge_2_message_board_write == 1 &&
1362  FLAME_loan_acknowledge_2_message_board_read == 1)
1363  rc = MB_SetAccessMode(b_loan_acknowledge_2, MB_MODE_READWRITE);
1364  #ifdef ERRCHECK
1365  if (rc != MB_SUCCESS)
1366  {
1367  fprintf(stderr, "ERROR: Could not set access mode of 'loan_acknowledge_2' board\n");
1368  switch(rc) {
1369  case MB_ERR_INVALID:
1370  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is invalid\n");
1371  break;
1372  case MB_ERR_LOCKED:
1373  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is locked\n");
1374  break;
1375  case MB_ERR_MEMALLOC:
1376  fprintf(stderr, "\t reason: out of memory\n");
1377  break;
1378  case MB_ERR_INTERNAL:
1379  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1380  break;
1381  default:
1382  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1383  break;
1384  }
1385 
1386  exit(rc);
1387  }
1388  #endif
1389  FLAME_debt_request_message_board_write = 0;
1390  FLAME_debt_request_message_board_read = 0;
1391  /* Sending agents */
1392  if(bank_start_state->agents != NULL) FLAME_debt_request_message_board_write = 1;
1393 
1394  /* Reading agents */
1395  if(centralbank_start_state->agents != NULL) FLAME_debt_request_message_board_read = 1;
1396 
1397  /* Call message board library with details */
1398  if(FLAME_debt_request_message_board_write == 0 &&
1399  FLAME_debt_request_message_board_read == 0)
1400  rc = MB_SetAccessMode(b_debt_request, MB_MODE_IDLE);
1401  if(FLAME_debt_request_message_board_write == 1 &&
1402  FLAME_debt_request_message_board_read == 0)
1403  rc = MB_SetAccessMode(b_debt_request, MB_MODE_WRITEONLY);
1404  if(FLAME_debt_request_message_board_write == 0 &&
1405  FLAME_debt_request_message_board_read == 1)
1406  rc = MB_SetAccessMode(b_debt_request, MB_MODE_READONLY);
1407  if(FLAME_debt_request_message_board_write == 1 &&
1408  FLAME_debt_request_message_board_read == 1)
1409  rc = MB_SetAccessMode(b_debt_request, MB_MODE_READWRITE);
1410  #ifdef ERRCHECK
1411  if (rc != MB_SUCCESS)
1412  {
1413  fprintf(stderr, "ERROR: Could not set access mode of 'debt_request' board\n");
1414  switch(rc) {
1415  case MB_ERR_INVALID:
1416  fprintf(stderr, "\t reason: 'debt_request' board is invalid\n");
1417  break;
1418  case MB_ERR_LOCKED:
1419  fprintf(stderr, "\t reason: 'debt_request' board is locked\n");
1420  break;
1421  case MB_ERR_MEMALLOC:
1422  fprintf(stderr, "\t reason: out of memory\n");
1423  break;
1424  case MB_ERR_INTERNAL:
1425  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1426  break;
1427  default:
1428  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1429  break;
1430  }
1431 
1432  exit(rc);
1433  }
1434  #endif
1435  FLAME_household_share_message_board_write = 0;
1436  FLAME_household_share_message_board_read = 0;
1437  /* Sending agents */
1438  if(equityfund_start_state->agents != NULL) FLAME_household_share_message_board_write = 1;
1439 
1440  /* Reading agents */
1441  if(household_start_state->agents != NULL) FLAME_household_share_message_board_read = 1;
1442 
1443  /* Call message board library with details */
1444  if(FLAME_household_share_message_board_write == 0 &&
1445  FLAME_household_share_message_board_read == 0)
1446  rc = MB_SetAccessMode(b_household_share, MB_MODE_IDLE);
1447  if(FLAME_household_share_message_board_write == 1 &&
1448  FLAME_household_share_message_board_read == 0)
1449  rc = MB_SetAccessMode(b_household_share, MB_MODE_WRITEONLY);
1450  if(FLAME_household_share_message_board_write == 0 &&
1451  FLAME_household_share_message_board_read == 1)
1452  rc = MB_SetAccessMode(b_household_share, MB_MODE_READONLY);
1453  if(FLAME_household_share_message_board_write == 1 &&
1454  FLAME_household_share_message_board_read == 1)
1455  rc = MB_SetAccessMode(b_household_share, MB_MODE_READWRITE);
1456  #ifdef ERRCHECK
1457  if (rc != MB_SUCCESS)
1458  {
1459  fprintf(stderr, "ERROR: Could not set access mode of 'household_share' board\n");
1460  switch(rc) {
1461  case MB_ERR_INVALID:
1462  fprintf(stderr, "\t reason: 'household_share' board is invalid\n");
1463  break;
1464  case MB_ERR_LOCKED:
1465  fprintf(stderr, "\t reason: 'household_share' board is locked\n");
1466  break;
1467  case MB_ERR_MEMALLOC:
1468  fprintf(stderr, "\t reason: out of memory\n");
1469  break;
1470  case MB_ERR_INTERNAL:
1471  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1472  break;
1473  default:
1474  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1475  break;
1476  }
1477 
1478  exit(rc);
1479  }
1480  #endif
1481  FLAME_capital_tax_message_board_write = 0;
1482  FLAME_capital_tax_message_board_read = 0;
1483  /* Sending agents */
1484  if(equityfund_start_state->agents != NULL) FLAME_capital_tax_message_board_write = 1;
1485 
1486  /* Reading agents */
1487  if(government_start_state->agents != NULL) FLAME_capital_tax_message_board_read = 1;
1488 
1489  /* Call message board library with details */
1490  if(FLAME_capital_tax_message_board_write == 0 &&
1491  FLAME_capital_tax_message_board_read == 0)
1492  rc = MB_SetAccessMode(b_capital_tax, MB_MODE_IDLE);
1493  if(FLAME_capital_tax_message_board_write == 1 &&
1494  FLAME_capital_tax_message_board_read == 0)
1495  rc = MB_SetAccessMode(b_capital_tax, MB_MODE_WRITEONLY);
1496  if(FLAME_capital_tax_message_board_write == 0 &&
1497  FLAME_capital_tax_message_board_read == 1)
1498  rc = MB_SetAccessMode(b_capital_tax, MB_MODE_READONLY);
1499  if(FLAME_capital_tax_message_board_write == 1 &&
1500  FLAME_capital_tax_message_board_read == 1)
1501  rc = MB_SetAccessMode(b_capital_tax, MB_MODE_READWRITE);
1502  #ifdef ERRCHECK
1503  if (rc != MB_SUCCESS)
1504  {
1505  fprintf(stderr, "ERROR: Could not set access mode of 'capital_tax' board\n");
1506  switch(rc) {
1507  case MB_ERR_INVALID:
1508  fprintf(stderr, "\t reason: 'capital_tax' board is invalid\n");
1509  break;
1510  case MB_ERR_LOCKED:
1511  fprintf(stderr, "\t reason: 'capital_tax' board is locked\n");
1512  break;
1513  case MB_ERR_MEMALLOC:
1514  fprintf(stderr, "\t reason: out of memory\n");
1515  break;
1516  case MB_ERR_INTERNAL:
1517  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1518  break;
1519  default:
1520  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1521  break;
1522  }
1523 
1524  exit(rc);
1525  }
1526  #endif
1527  FLAME_labour_tax_message_board_write = 0;
1528  FLAME_labour_tax_message_board_read = 0;
1529  /* Sending agents */
1530  if(firm_start_state->agents != NULL) FLAME_labour_tax_message_board_write = 1;
1531 
1532  /* Reading agents */
1533  if(government_start_state->agents != NULL) FLAME_labour_tax_message_board_read = 1;
1534 
1535  /* Call message board library with details */
1536  if(FLAME_labour_tax_message_board_write == 0 &&
1537  FLAME_labour_tax_message_board_read == 0)
1538  rc = MB_SetAccessMode(b_labour_tax, MB_MODE_IDLE);
1539  if(FLAME_labour_tax_message_board_write == 1 &&
1540  FLAME_labour_tax_message_board_read == 0)
1541  rc = MB_SetAccessMode(b_labour_tax, MB_MODE_WRITEONLY);
1542  if(FLAME_labour_tax_message_board_write == 0 &&
1543  FLAME_labour_tax_message_board_read == 1)
1544  rc = MB_SetAccessMode(b_labour_tax, MB_MODE_READONLY);
1545  if(FLAME_labour_tax_message_board_write == 1 &&
1546  FLAME_labour_tax_message_board_read == 1)
1547  rc = MB_SetAccessMode(b_labour_tax, MB_MODE_READWRITE);
1548  #ifdef ERRCHECK
1549  if (rc != MB_SUCCESS)
1550  {
1551  fprintf(stderr, "ERROR: Could not set access mode of 'labour_tax' board\n");
1552  switch(rc) {
1553  case MB_ERR_INVALID:
1554  fprintf(stderr, "\t reason: 'labour_tax' board is invalid\n");
1555  break;
1556  case MB_ERR_LOCKED:
1557  fprintf(stderr, "\t reason: 'labour_tax' board is locked\n");
1558  break;
1559  case MB_ERR_MEMALLOC:
1560  fprintf(stderr, "\t reason: out of memory\n");
1561  break;
1562  case MB_ERR_INTERNAL:
1563  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1564  break;
1565  default:
1566  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1567  break;
1568  }
1569 
1570  exit(rc);
1571  }
1572  #endif
1573  FLAME_unemployment_benefit_message_board_write = 0;
1574  FLAME_unemployment_benefit_message_board_read = 0;
1575  /* Sending agents */
1576  if(government_start_state->agents != NULL) FLAME_unemployment_benefit_message_board_write = 1;
1577 
1578  /* Reading agents */
1579  if(household_start_state->agents != NULL) FLAME_unemployment_benefit_message_board_read = 1;
1580 
1581  /* Call message board library with details */
1582  if(FLAME_unemployment_benefit_message_board_write == 0 &&
1583  FLAME_unemployment_benefit_message_board_read == 0)
1584  rc = MB_SetAccessMode(b_unemployment_benefit, MB_MODE_IDLE);
1585  if(FLAME_unemployment_benefit_message_board_write == 1 &&
1586  FLAME_unemployment_benefit_message_board_read == 0)
1587  rc = MB_SetAccessMode(b_unemployment_benefit, MB_MODE_WRITEONLY);
1588  if(FLAME_unemployment_benefit_message_board_write == 0 &&
1589  FLAME_unemployment_benefit_message_board_read == 1)
1590  rc = MB_SetAccessMode(b_unemployment_benefit, MB_MODE_READONLY);
1591  if(FLAME_unemployment_benefit_message_board_write == 1 &&
1592  FLAME_unemployment_benefit_message_board_read == 1)
1593  rc = MB_SetAccessMode(b_unemployment_benefit, MB_MODE_READWRITE);
1594  #ifdef ERRCHECK
1595  if (rc != MB_SUCCESS)
1596  {
1597  fprintf(stderr, "ERROR: Could not set access mode of 'unemployment_benefit' board\n");
1598  switch(rc) {
1599  case MB_ERR_INVALID:
1600  fprintf(stderr, "\t reason: 'unemployment_benefit' board is invalid\n");
1601  break;
1602  case MB_ERR_LOCKED:
1603  fprintf(stderr, "\t reason: 'unemployment_benefit' board is locked\n");
1604  break;
1605  case MB_ERR_MEMALLOC:
1606  fprintf(stderr, "\t reason: out of memory\n");
1607  break;
1608  case MB_ERR_INTERNAL:
1609  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1610  break;
1611  default:
1612  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1613  break;
1614  }
1615 
1616  exit(rc);
1617  }
1618  #endif
1619  FLAME_general_benefit_message_board_write = 0;
1620  FLAME_general_benefit_message_board_read = 0;
1621  /* Sending agents */
1622  if(government_start_state->agents != NULL) FLAME_general_benefit_message_board_write = 1;
1623 
1624  /* Reading agents */
1625  if(household_start_state->agents != NULL) FLAME_general_benefit_message_board_read = 1;
1626 
1627  /* Call message board library with details */
1628  if(FLAME_general_benefit_message_board_write == 0 &&
1629  FLAME_general_benefit_message_board_read == 0)
1630  rc = MB_SetAccessMode(b_general_benefit, MB_MODE_IDLE);
1631  if(FLAME_general_benefit_message_board_write == 1 &&
1632  FLAME_general_benefit_message_board_read == 0)
1633  rc = MB_SetAccessMode(b_general_benefit, MB_MODE_WRITEONLY);
1634  if(FLAME_general_benefit_message_board_write == 0 &&
1635  FLAME_general_benefit_message_board_read == 1)
1636  rc = MB_SetAccessMode(b_general_benefit, MB_MODE_READONLY);
1637  if(FLAME_general_benefit_message_board_write == 1 &&
1638  FLAME_general_benefit_message_board_read == 1)
1639  rc = MB_SetAccessMode(b_general_benefit, MB_MODE_READWRITE);
1640  #ifdef ERRCHECK
1641  if (rc != MB_SUCCESS)
1642  {
1643  fprintf(stderr, "ERROR: Could not set access mode of 'general_benefit' board\n");
1644  switch(rc) {
1645  case MB_ERR_INVALID:
1646  fprintf(stderr, "\t reason: 'general_benefit' board is invalid\n");
1647  break;
1648  case MB_ERR_LOCKED:
1649  fprintf(stderr, "\t reason: 'general_benefit' board is locked\n");
1650  break;
1651  case MB_ERR_MEMALLOC:
1652  fprintf(stderr, "\t reason: out of memory\n");
1653  break;
1654  case MB_ERR_INTERNAL:
1655  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1656  break;
1657  default:
1658  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1659  break;
1660  }
1661 
1662  exit(rc);
1663  }
1664  #endif
1665  FLAME_fund_request_message_board_write = 0;
1666  FLAME_fund_request_message_board_read = 0;
1667  /* Sending agents */
1668  if(firm_start_state->agents != NULL) FLAME_fund_request_message_board_write = 1;
1669 
1670  /* Reading agents */
1671  if(equityfund_start_state->agents != NULL) FLAME_fund_request_message_board_read = 1;
1672 
1673  /* Call message board library with details */
1674  if(FLAME_fund_request_message_board_write == 0 &&
1675  FLAME_fund_request_message_board_read == 0)
1676  rc = MB_SetAccessMode(b_fund_request, MB_MODE_IDLE);
1677  if(FLAME_fund_request_message_board_write == 1 &&
1678  FLAME_fund_request_message_board_read == 0)
1679  rc = MB_SetAccessMode(b_fund_request, MB_MODE_WRITEONLY);
1680  if(FLAME_fund_request_message_board_write == 0 &&
1681  FLAME_fund_request_message_board_read == 1)
1682  rc = MB_SetAccessMode(b_fund_request, MB_MODE_READONLY);
1683  if(FLAME_fund_request_message_board_write == 1 &&
1684  FLAME_fund_request_message_board_read == 1)
1685  rc = MB_SetAccessMode(b_fund_request, MB_MODE_READWRITE);
1686  #ifdef ERRCHECK
1687  if (rc != MB_SUCCESS)
1688  {
1689  fprintf(stderr, "ERROR: Could not set access mode of 'fund_request' board\n");
1690  switch(rc) {
1691  case MB_ERR_INVALID:
1692  fprintf(stderr, "\t reason: 'fund_request' board is invalid\n");
1693  break;
1694  case MB_ERR_LOCKED:
1695  fprintf(stderr, "\t reason: 'fund_request' board is locked\n");
1696  break;
1697  case MB_ERR_MEMALLOC:
1698  fprintf(stderr, "\t reason: out of memory\n");
1699  break;
1700  case MB_ERR_INTERNAL:
1701  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1702  break;
1703  default:
1704  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1705  break;
1706  }
1707 
1708  exit(rc);
1709  }
1710  #endif
1711  FLAME_fund_request_ack_message_board_write = 0;
1712  FLAME_fund_request_ack_message_board_read = 0;
1713  /* Sending agents */
1714  if(equityfund_start_state->agents != NULL) FLAME_fund_request_ack_message_board_write = 1;
1715 
1716  /* Reading agents */
1717  if(firm_start_state->agents != NULL) FLAME_fund_request_ack_message_board_read = 1;
1718 
1719  /* Call message board library with details */
1720  if(FLAME_fund_request_ack_message_board_write == 0 &&
1721  FLAME_fund_request_ack_message_board_read == 0)
1722  rc = MB_SetAccessMode(b_fund_request_ack, MB_MODE_IDLE);
1723  if(FLAME_fund_request_ack_message_board_write == 1 &&
1724  FLAME_fund_request_ack_message_board_read == 0)
1725  rc = MB_SetAccessMode(b_fund_request_ack, MB_MODE_WRITEONLY);
1726  if(FLAME_fund_request_ack_message_board_write == 0 &&
1727  FLAME_fund_request_ack_message_board_read == 1)
1728  rc = MB_SetAccessMode(b_fund_request_ack, MB_MODE_READONLY);
1729  if(FLAME_fund_request_ack_message_board_write == 1 &&
1730  FLAME_fund_request_ack_message_board_read == 1)
1731  rc = MB_SetAccessMode(b_fund_request_ack, MB_MODE_READWRITE);
1732  #ifdef ERRCHECK
1733  if (rc != MB_SUCCESS)
1734  {
1735  fprintf(stderr, "ERROR: Could not set access mode of 'fund_request_ack' board\n");
1736  switch(rc) {
1737  case MB_ERR_INVALID:
1738  fprintf(stderr, "\t reason: 'fund_request_ack' board is invalid\n");
1739  break;
1740  case MB_ERR_LOCKED:
1741  fprintf(stderr, "\t reason: 'fund_request_ack' board is locked\n");
1742  break;
1743  case MB_ERR_MEMALLOC:
1744  fprintf(stderr, "\t reason: out of memory\n");
1745  break;
1746  case MB_ERR_INTERNAL:
1747  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1748  break;
1749  default:
1750  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1751  break;
1752  }
1753 
1754  exit(rc);
1755  }
1756  #endif
1757  FLAME_new_entrant_loan_message_board_write = 0;
1758  FLAME_new_entrant_loan_message_board_read = 0;
1759  /* Sending agents */
1760  if(firm_start_state->agents != NULL) FLAME_new_entrant_loan_message_board_write = 1;
1761 
1762  /* Reading agents */
1763  if(bank_start_state->agents != NULL) FLAME_new_entrant_loan_message_board_read = 1;
1764 
1765  /* Call message board library with details */
1766  if(FLAME_new_entrant_loan_message_board_write == 0 &&
1767  FLAME_new_entrant_loan_message_board_read == 0)
1768  rc = MB_SetAccessMode(b_new_entrant_loan, MB_MODE_IDLE);
1769  if(FLAME_new_entrant_loan_message_board_write == 1 &&
1770  FLAME_new_entrant_loan_message_board_read == 0)
1771  rc = MB_SetAccessMode(b_new_entrant_loan, MB_MODE_WRITEONLY);
1772  if(FLAME_new_entrant_loan_message_board_write == 0 &&
1773  FLAME_new_entrant_loan_message_board_read == 1)
1774  rc = MB_SetAccessMode(b_new_entrant_loan, MB_MODE_READONLY);
1775  if(FLAME_new_entrant_loan_message_board_write == 1 &&
1776  FLAME_new_entrant_loan_message_board_read == 1)
1777  rc = MB_SetAccessMode(b_new_entrant_loan, MB_MODE_READWRITE);
1778  #ifdef ERRCHECK
1779  if (rc != MB_SUCCESS)
1780  {
1781  fprintf(stderr, "ERROR: Could not set access mode of 'new_entrant_loan' board\n");
1782  switch(rc) {
1783  case MB_ERR_INVALID:
1784  fprintf(stderr, "\t reason: 'new_entrant_loan' board is invalid\n");
1785  break;
1786  case MB_ERR_LOCKED:
1787  fprintf(stderr, "\t reason: 'new_entrant_loan' board is locked\n");
1788  break;
1789  case MB_ERR_MEMALLOC:
1790  fprintf(stderr, "\t reason: out of memory\n");
1791  break;
1792  case MB_ERR_INTERNAL:
1793  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1794  break;
1795  default:
1796  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1797  break;
1798  }
1799 
1800  exit(rc);
1801  }
1802  #endif
1803  FLAME_interest_on_loan_message_board_write = 0;
1804  FLAME_interest_on_loan_message_board_read = 0;
1805  /* Sending agents */
1806  if(firm_start_state->agents != NULL) FLAME_interest_on_loan_message_board_write = 1;
1807 
1808  /* Reading agents */
1809  if(bank_start_state->agents != NULL) FLAME_interest_on_loan_message_board_read = 1;
1810 
1811  /* Call message board library with details */
1812  if(FLAME_interest_on_loan_message_board_write == 0 &&
1813  FLAME_interest_on_loan_message_board_read == 0)
1814  rc = MB_SetAccessMode(b_interest_on_loan, MB_MODE_IDLE);
1815  if(FLAME_interest_on_loan_message_board_write == 1 &&
1816  FLAME_interest_on_loan_message_board_read == 0)
1817  rc = MB_SetAccessMode(b_interest_on_loan, MB_MODE_WRITEONLY);
1818  if(FLAME_interest_on_loan_message_board_write == 0 &&
1819  FLAME_interest_on_loan_message_board_read == 1)
1820  rc = MB_SetAccessMode(b_interest_on_loan, MB_MODE_READONLY);
1821  if(FLAME_interest_on_loan_message_board_write == 1 &&
1822  FLAME_interest_on_loan_message_board_read == 1)
1823  rc = MB_SetAccessMode(b_interest_on_loan, MB_MODE_READWRITE);
1824  #ifdef ERRCHECK
1825  if (rc != MB_SUCCESS)
1826  {
1827  fprintf(stderr, "ERROR: Could not set access mode of 'interest_on_loan' board\n");
1828  switch(rc) {
1829  case MB_ERR_INVALID:
1830  fprintf(stderr, "\t reason: 'interest_on_loan' board is invalid\n");
1831  break;
1832  case MB_ERR_LOCKED:
1833  fprintf(stderr, "\t reason: 'interest_on_loan' board is locked\n");
1834  break;
1835  case MB_ERR_MEMALLOC:
1836  fprintf(stderr, "\t reason: out of memory\n");
1837  break;
1838  case MB_ERR_INTERNAL:
1839  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1840  break;
1841  default:
1842  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1843  break;
1844  }
1845 
1846  exit(rc);
1847  }
1848  #endif
1849  FLAME_loan_writeoff_message_board_write = 0;
1850  FLAME_loan_writeoff_message_board_read = 0;
1851  /* Sending agents */
1852  if(firm_start_state->agents != NULL) FLAME_loan_writeoff_message_board_write = 1;
1853 
1854  /* Reading agents */
1855  if(bank_start_state->agents != NULL) FLAME_loan_writeoff_message_board_read = 1;
1856 
1857  /* Call message board library with details */
1858  if(FLAME_loan_writeoff_message_board_write == 0 &&
1859  FLAME_loan_writeoff_message_board_read == 0)
1860  rc = MB_SetAccessMode(b_loan_writeoff, MB_MODE_IDLE);
1861  if(FLAME_loan_writeoff_message_board_write == 1 &&
1862  FLAME_loan_writeoff_message_board_read == 0)
1863  rc = MB_SetAccessMode(b_loan_writeoff, MB_MODE_WRITEONLY);
1864  if(FLAME_loan_writeoff_message_board_write == 0 &&
1865  FLAME_loan_writeoff_message_board_read == 1)
1866  rc = MB_SetAccessMode(b_loan_writeoff, MB_MODE_READONLY);
1867  if(FLAME_loan_writeoff_message_board_write == 1 &&
1868  FLAME_loan_writeoff_message_board_read == 1)
1869  rc = MB_SetAccessMode(b_loan_writeoff, MB_MODE_READWRITE);
1870  #ifdef ERRCHECK
1871  if (rc != MB_SUCCESS)
1872  {
1873  fprintf(stderr, "ERROR: Could not set access mode of 'loan_writeoff' board\n");
1874  switch(rc) {
1875  case MB_ERR_INVALID:
1876  fprintf(stderr, "\t reason: 'loan_writeoff' board is invalid\n");
1877  break;
1878  case MB_ERR_LOCKED:
1879  fprintf(stderr, "\t reason: 'loan_writeoff' board is locked\n");
1880  break;
1881  case MB_ERR_MEMALLOC:
1882  fprintf(stderr, "\t reason: out of memory\n");
1883  break;
1884  case MB_ERR_INTERNAL:
1885  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1886  break;
1887  default:
1888  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1889  break;
1890  }
1891 
1892  exit(rc);
1893  }
1894  #endif
1895  FLAME_firm_net_profit_message_board_write = 0;
1896  FLAME_firm_net_profit_message_board_read = 0;
1897  /* Sending agents */
1898  if(firm_start_state->agents != NULL) FLAME_firm_net_profit_message_board_write = 1;
1899 
1900  /* Reading agents */
1901  if(equityfund_start_state->agents != NULL) FLAME_firm_net_profit_message_board_read = 1;
1902 
1903  /* Call message board library with details */
1904  if(FLAME_firm_net_profit_message_board_write == 0 &&
1905  FLAME_firm_net_profit_message_board_read == 0)
1906  rc = MB_SetAccessMode(b_firm_net_profit, MB_MODE_IDLE);
1907  if(FLAME_firm_net_profit_message_board_write == 1 &&
1908  FLAME_firm_net_profit_message_board_read == 0)
1909  rc = MB_SetAccessMode(b_firm_net_profit, MB_MODE_WRITEONLY);
1910  if(FLAME_firm_net_profit_message_board_write == 0 &&
1911  FLAME_firm_net_profit_message_board_read == 1)
1912  rc = MB_SetAccessMode(b_firm_net_profit, MB_MODE_READONLY);
1913  if(FLAME_firm_net_profit_message_board_write == 1 &&
1914  FLAME_firm_net_profit_message_board_read == 1)
1915  rc = MB_SetAccessMode(b_firm_net_profit, MB_MODE_READWRITE);
1916  #ifdef ERRCHECK
1917  if (rc != MB_SUCCESS)
1918  {
1919  fprintf(stderr, "ERROR: Could not set access mode of 'firm_net_profit' board\n");
1920  switch(rc) {
1921  case MB_ERR_INVALID:
1922  fprintf(stderr, "\t reason: 'firm_net_profit' board is invalid\n");
1923  break;
1924  case MB_ERR_LOCKED:
1925  fprintf(stderr, "\t reason: 'firm_net_profit' board is locked\n");
1926  break;
1927  case MB_ERR_MEMALLOC:
1928  fprintf(stderr, "\t reason: out of memory\n");
1929  break;
1930  case MB_ERR_INTERNAL:
1931  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1932  break;
1933  default:
1934  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1935  break;
1936  }
1937 
1938  exit(rc);
1939  }
1940  #endif
1941  FLAME_bank_net_profit_message_board_write = 0;
1942  FLAME_bank_net_profit_message_board_read = 0;
1943  /* Sending agents */
1944  if(bank_start_state->agents != NULL) FLAME_bank_net_profit_message_board_write = 1;
1945 
1946  /* Reading agents */
1947  if(equityfund_start_state->agents != NULL) FLAME_bank_net_profit_message_board_read = 1;
1948 
1949  /* Call message board library with details */
1950  if(FLAME_bank_net_profit_message_board_write == 0 &&
1951  FLAME_bank_net_profit_message_board_read == 0)
1952  rc = MB_SetAccessMode(b_bank_net_profit, MB_MODE_IDLE);
1953  if(FLAME_bank_net_profit_message_board_write == 1 &&
1954  FLAME_bank_net_profit_message_board_read == 0)
1955  rc = MB_SetAccessMode(b_bank_net_profit, MB_MODE_WRITEONLY);
1956  if(FLAME_bank_net_profit_message_board_write == 0 &&
1957  FLAME_bank_net_profit_message_board_read == 1)
1958  rc = MB_SetAccessMode(b_bank_net_profit, MB_MODE_READONLY);
1959  if(FLAME_bank_net_profit_message_board_write == 1 &&
1960  FLAME_bank_net_profit_message_board_read == 1)
1961  rc = MB_SetAccessMode(b_bank_net_profit, MB_MODE_READWRITE);
1962  #ifdef ERRCHECK
1963  if (rc != MB_SUCCESS)
1964  {
1965  fprintf(stderr, "ERROR: Could not set access mode of 'bank_net_profit' board\n");
1966  switch(rc) {
1967  case MB_ERR_INVALID:
1968  fprintf(stderr, "\t reason: 'bank_net_profit' board is invalid\n");
1969  break;
1970  case MB_ERR_LOCKED:
1971  fprintf(stderr, "\t reason: 'bank_net_profit' board is locked\n");
1972  break;
1973  case MB_ERR_MEMALLOC:
1974  fprintf(stderr, "\t reason: out of memory\n");
1975  break;
1976  case MB_ERR_INTERNAL:
1977  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
1978  break;
1979  default:
1980  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
1981  break;
1982  }
1983 
1984  exit(rc);
1985  }
1986  #endif
1987  FLAME_bank_centralbank_interest_payment_message_board_write = 0;
1988  FLAME_bank_centralbank_interest_payment_message_board_read = 0;
1989  /* Sending agents */
1990  if(bank_start_state->agents != NULL) FLAME_bank_centralbank_interest_payment_message_board_write = 1;
1991 
1992  /* Reading agents */
1993  if(centralbank_start_state->agents != NULL) FLAME_bank_centralbank_interest_payment_message_board_read = 1;
1994 
1995  /* Call message board library with details */
1996  if(FLAME_bank_centralbank_interest_payment_message_board_write == 0 &&
1997  FLAME_bank_centralbank_interest_payment_message_board_read == 0)
1998  rc = MB_SetAccessMode(b_bank_centralbank_interest_payment, MB_MODE_IDLE);
1999  if(FLAME_bank_centralbank_interest_payment_message_board_write == 1 &&
2000  FLAME_bank_centralbank_interest_payment_message_board_read == 0)
2001  rc = MB_SetAccessMode(b_bank_centralbank_interest_payment, MB_MODE_WRITEONLY);
2002  if(FLAME_bank_centralbank_interest_payment_message_board_write == 0 &&
2003  FLAME_bank_centralbank_interest_payment_message_board_read == 1)
2004  rc = MB_SetAccessMode(b_bank_centralbank_interest_payment, MB_MODE_READONLY);
2005  if(FLAME_bank_centralbank_interest_payment_message_board_write == 1 &&
2006  FLAME_bank_centralbank_interest_payment_message_board_read == 1)
2007  rc = MB_SetAccessMode(b_bank_centralbank_interest_payment, MB_MODE_READWRITE);
2008  #ifdef ERRCHECK
2009  if (rc != MB_SUCCESS)
2010  {
2011  fprintf(stderr, "ERROR: Could not set access mode of 'bank_centralbank_interest_payment' board\n");
2012  switch(rc) {
2013  case MB_ERR_INVALID:
2014  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is invalid\n");
2015  break;
2016  case MB_ERR_LOCKED:
2017  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is locked\n");
2018  break;
2019  case MB_ERR_MEMALLOC:
2020  fprintf(stderr, "\t reason: out of memory\n");
2021  break;
2022  case MB_ERR_INTERNAL:
2023  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2024  break;
2025  default:
2026  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2027  break;
2028  }
2029 
2030  exit(rc);
2031  }
2032  #endif
2033  FLAME_bank_centralbank_debt_payment_message_board_write = 0;
2034  FLAME_bank_centralbank_debt_payment_message_board_read = 0;
2035  /* Sending agents */
2036  if(bank_start_state->agents != NULL) FLAME_bank_centralbank_debt_payment_message_board_write = 1;
2037 
2038  /* Reading agents */
2039  if(centralbank_start_state->agents != NULL) FLAME_bank_centralbank_debt_payment_message_board_read = 1;
2040 
2041  /* Call message board library with details */
2042  if(FLAME_bank_centralbank_debt_payment_message_board_write == 0 &&
2043  FLAME_bank_centralbank_debt_payment_message_board_read == 0)
2044  rc = MB_SetAccessMode(b_bank_centralbank_debt_payment, MB_MODE_IDLE);
2045  if(FLAME_bank_centralbank_debt_payment_message_board_write == 1 &&
2046  FLAME_bank_centralbank_debt_payment_message_board_read == 0)
2047  rc = MB_SetAccessMode(b_bank_centralbank_debt_payment, MB_MODE_WRITEONLY);
2048  if(FLAME_bank_centralbank_debt_payment_message_board_write == 0 &&
2049  FLAME_bank_centralbank_debt_payment_message_board_read == 1)
2050  rc = MB_SetAccessMode(b_bank_centralbank_debt_payment, MB_MODE_READONLY);
2051  if(FLAME_bank_centralbank_debt_payment_message_board_write == 1 &&
2052  FLAME_bank_centralbank_debt_payment_message_board_read == 1)
2053  rc = MB_SetAccessMode(b_bank_centralbank_debt_payment, MB_MODE_READWRITE);
2054  #ifdef ERRCHECK
2055  if (rc != MB_SUCCESS)
2056  {
2057  fprintf(stderr, "ERROR: Could not set access mode of 'bank_centralbank_debt_payment' board\n");
2058  switch(rc) {
2059  case MB_ERR_INVALID:
2060  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is invalid\n");
2061  break;
2062  case MB_ERR_LOCKED:
2063  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is locked\n");
2064  break;
2065  case MB_ERR_MEMALLOC:
2066  fprintf(stderr, "\t reason: out of memory\n");
2067  break;
2068  case MB_ERR_INTERNAL:
2069  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2070  break;
2071  default:
2072  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2073  break;
2074  }
2075 
2076  exit(rc);
2077  }
2078  #endif
2079  FLAME_centralbank_government_profit_message_board_write = 0;
2080  FLAME_centralbank_government_profit_message_board_read = 0;
2081  /* Sending agents */
2082  if(centralbank_start_state->agents != NULL) FLAME_centralbank_government_profit_message_board_write = 1;
2083 
2084  /* Reading agents */
2085  if(government_start_state->agents != NULL) FLAME_centralbank_government_profit_message_board_read = 1;
2086 
2087  /* Call message board library with details */
2088  if(FLAME_centralbank_government_profit_message_board_write == 0 &&
2089  FLAME_centralbank_government_profit_message_board_read == 0)
2090  rc = MB_SetAccessMode(b_centralbank_government_profit, MB_MODE_IDLE);
2091  if(FLAME_centralbank_government_profit_message_board_write == 1 &&
2092  FLAME_centralbank_government_profit_message_board_read == 0)
2093  rc = MB_SetAccessMode(b_centralbank_government_profit, MB_MODE_WRITEONLY);
2094  if(FLAME_centralbank_government_profit_message_board_write == 0 &&
2095  FLAME_centralbank_government_profit_message_board_read == 1)
2096  rc = MB_SetAccessMode(b_centralbank_government_profit, MB_MODE_READONLY);
2097  if(FLAME_centralbank_government_profit_message_board_write == 1 &&
2098  FLAME_centralbank_government_profit_message_board_read == 1)
2099  rc = MB_SetAccessMode(b_centralbank_government_profit, MB_MODE_READWRITE);
2100  #ifdef ERRCHECK
2101  if (rc != MB_SUCCESS)
2102  {
2103  fprintf(stderr, "ERROR: Could not set access mode of 'centralbank_government_profit' board\n");
2104  switch(rc) {
2105  case MB_ERR_INVALID:
2106  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is invalid\n");
2107  break;
2108  case MB_ERR_LOCKED:
2109  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is locked\n");
2110  break;
2111  case MB_ERR_MEMALLOC:
2112  fprintf(stderr, "\t reason: out of memory\n");
2113  break;
2114  case MB_ERR_INTERNAL:
2115  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2116  break;
2117  default:
2118  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2119  break;
2120  }
2121 
2122  exit(rc);
2123  }
2124  #endif
2125  FLAME_housing_price_message_board_write = 0;
2126  FLAME_housing_price_message_board_read = 0;
2127  /* Sending agents */
2128  if(reagency_start_state->agents != NULL) FLAME_housing_price_message_board_write = 1;
2129 
2130  /* Reading agents */
2131  if(firm_start_state->agents != NULL) FLAME_housing_price_message_board_read = 1;
2132  if(household_start_state->agents != NULL) FLAME_housing_price_message_board_read = 1;
2133 
2134  /* Call message board library with details */
2135  if(FLAME_housing_price_message_board_write == 0 &&
2136  FLAME_housing_price_message_board_read == 0)
2137  rc = MB_SetAccessMode(b_housing_price, MB_MODE_IDLE);
2138  if(FLAME_housing_price_message_board_write == 1 &&
2139  FLAME_housing_price_message_board_read == 0)
2140  rc = MB_SetAccessMode(b_housing_price, MB_MODE_WRITEONLY);
2141  if(FLAME_housing_price_message_board_write == 0 &&
2142  FLAME_housing_price_message_board_read == 1)
2143  rc = MB_SetAccessMode(b_housing_price, MB_MODE_READONLY);
2144  if(FLAME_housing_price_message_board_write == 1 &&
2145  FLAME_housing_price_message_board_read == 1)
2146  rc = MB_SetAccessMode(b_housing_price, MB_MODE_READWRITE);
2147  #ifdef ERRCHECK
2148  if (rc != MB_SUCCESS)
2149  {
2150  fprintf(stderr, "ERROR: Could not set access mode of 'housing_price' board\n");
2151  switch(rc) {
2152  case MB_ERR_INVALID:
2153  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
2154  break;
2155  case MB_ERR_LOCKED:
2156  fprintf(stderr, "\t reason: 'housing_price' board is locked\n");
2157  break;
2158  case MB_ERR_MEMALLOC:
2159  fprintf(stderr, "\t reason: out of memory\n");
2160  break;
2161  case MB_ERR_INTERNAL:
2162  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2163  break;
2164  default:
2165  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2166  break;
2167  }
2168 
2169  exit(rc);
2170  }
2171  #endif
2172  FLAME_buy_housing_message_board_write = 0;
2173  FLAME_buy_housing_message_board_read = 0;
2174  /* Sending agents */
2175  if(household_start_state->agents != NULL) FLAME_buy_housing_message_board_write = 1;
2176 
2177  /* Reading agents */
2178  if(reagency_start_state->agents != NULL) FLAME_buy_housing_message_board_read = 1;
2179 
2180  /* Call message board library with details */
2181  if(FLAME_buy_housing_message_board_write == 0 &&
2182  FLAME_buy_housing_message_board_read == 0)
2183  rc = MB_SetAccessMode(b_buy_housing, MB_MODE_IDLE);
2184  if(FLAME_buy_housing_message_board_write == 1 &&
2185  FLAME_buy_housing_message_board_read == 0)
2186  rc = MB_SetAccessMode(b_buy_housing, MB_MODE_WRITEONLY);
2187  if(FLAME_buy_housing_message_board_write == 0 &&
2188  FLAME_buy_housing_message_board_read == 1)
2189  rc = MB_SetAccessMode(b_buy_housing, MB_MODE_READONLY);
2190  if(FLAME_buy_housing_message_board_write == 1 &&
2191  FLAME_buy_housing_message_board_read == 1)
2192  rc = MB_SetAccessMode(b_buy_housing, MB_MODE_READWRITE);
2193  #ifdef ERRCHECK
2194  if (rc != MB_SUCCESS)
2195  {
2196  fprintf(stderr, "ERROR: Could not set access mode of 'buy_housing' board\n");
2197  switch(rc) {
2198  case MB_ERR_INVALID:
2199  fprintf(stderr, "\t reason: 'buy_housing' board is invalid\n");
2200  break;
2201  case MB_ERR_LOCKED:
2202  fprintf(stderr, "\t reason: 'buy_housing' board is locked\n");
2203  break;
2204  case MB_ERR_MEMALLOC:
2205  fprintf(stderr, "\t reason: out of memory\n");
2206  break;
2207  case MB_ERR_INTERNAL:
2208  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2209  break;
2210  default:
2211  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2212  break;
2213  }
2214 
2215  exit(rc);
2216  }
2217  #endif
2218  FLAME_sell_housing_message_board_write = 0;
2219  FLAME_sell_housing_message_board_read = 0;
2220  /* Sending agents */
2221  if(firm_start_state->agents != NULL) FLAME_sell_housing_message_board_write = 1;
2222  if(household_start_state->agents != NULL) FLAME_sell_housing_message_board_write = 1;
2223 
2224  /* Reading agents */
2225  if(reagency_start_state->agents != NULL) FLAME_sell_housing_message_board_read = 1;
2226 
2227  /* Call message board library with details */
2228  if(FLAME_sell_housing_message_board_write == 0 &&
2229  FLAME_sell_housing_message_board_read == 0)
2230  rc = MB_SetAccessMode(b_sell_housing, MB_MODE_IDLE);
2231  if(FLAME_sell_housing_message_board_write == 1 &&
2232  FLAME_sell_housing_message_board_read == 0)
2233  rc = MB_SetAccessMode(b_sell_housing, MB_MODE_WRITEONLY);
2234  if(FLAME_sell_housing_message_board_write == 0 &&
2235  FLAME_sell_housing_message_board_read == 1)
2236  rc = MB_SetAccessMode(b_sell_housing, MB_MODE_READONLY);
2237  if(FLAME_sell_housing_message_board_write == 1 &&
2238  FLAME_sell_housing_message_board_read == 1)
2239  rc = MB_SetAccessMode(b_sell_housing, MB_MODE_READWRITE);
2240  #ifdef ERRCHECK
2241  if (rc != MB_SUCCESS)
2242  {
2243  fprintf(stderr, "ERROR: Could not set access mode of 'sell_housing' board\n");
2244  switch(rc) {
2245  case MB_ERR_INVALID:
2246  fprintf(stderr, "\t reason: 'sell_housing' board is invalid\n");
2247  break;
2248  case MB_ERR_LOCKED:
2249  fprintf(stderr, "\t reason: 'sell_housing' board is locked\n");
2250  break;
2251  case MB_ERR_MEMALLOC:
2252  fprintf(stderr, "\t reason: out of memory\n");
2253  break;
2254  case MB_ERR_INTERNAL:
2255  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2256  break;
2257  default:
2258  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2259  break;
2260  }
2261 
2262  exit(rc);
2263  }
2264  #endif
2265  FLAME_bought_housing_message_board_write = 0;
2266  FLAME_bought_housing_message_board_read = 0;
2267  /* Sending agents */
2268  if(reagency_start_state->agents != NULL) FLAME_bought_housing_message_board_write = 1;
2269 
2270  /* Reading agents */
2271  if(household_start_state->agents != NULL) FLAME_bought_housing_message_board_read = 1;
2272 
2273  /* Call message board library with details */
2274  if(FLAME_bought_housing_message_board_write == 0 &&
2275  FLAME_bought_housing_message_board_read == 0)
2276  rc = MB_SetAccessMode(b_bought_housing, MB_MODE_IDLE);
2277  if(FLAME_bought_housing_message_board_write == 1 &&
2278  FLAME_bought_housing_message_board_read == 0)
2279  rc = MB_SetAccessMode(b_bought_housing, MB_MODE_WRITEONLY);
2280  if(FLAME_bought_housing_message_board_write == 0 &&
2281  FLAME_bought_housing_message_board_read == 1)
2282  rc = MB_SetAccessMode(b_bought_housing, MB_MODE_READONLY);
2283  if(FLAME_bought_housing_message_board_write == 1 &&
2284  FLAME_bought_housing_message_board_read == 1)
2285  rc = MB_SetAccessMode(b_bought_housing, MB_MODE_READWRITE);
2286  #ifdef ERRCHECK
2287  if (rc != MB_SUCCESS)
2288  {
2289  fprintf(stderr, "ERROR: Could not set access mode of 'bought_housing' board\n");
2290  switch(rc) {
2291  case MB_ERR_INVALID:
2292  fprintf(stderr, "\t reason: 'bought_housing' board is invalid\n");
2293  break;
2294  case MB_ERR_LOCKED:
2295  fprintf(stderr, "\t reason: 'bought_housing' board is locked\n");
2296  break;
2297  case MB_ERR_MEMALLOC:
2298  fprintf(stderr, "\t reason: out of memory\n");
2299  break;
2300  case MB_ERR_INTERNAL:
2301  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2302  break;
2303  default:
2304  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2305  break;
2306  }
2307 
2308  exit(rc);
2309  }
2310  #endif
2311  FLAME_sold_housing_message_board_write = 0;
2312  FLAME_sold_housing_message_board_read = 0;
2313  /* Sending agents */
2314  if(reagency_start_state->agents != NULL) FLAME_sold_housing_message_board_write = 1;
2315 
2316  /* Reading agents */
2317  if(firm_start_state->agents != NULL) FLAME_sold_housing_message_board_read = 1;
2318  if(household_start_state->agents != NULL) FLAME_sold_housing_message_board_read = 1;
2319 
2320  /* Call message board library with details */
2321  if(FLAME_sold_housing_message_board_write == 0 &&
2322  FLAME_sold_housing_message_board_read == 0)
2323  rc = MB_SetAccessMode(b_sold_housing, MB_MODE_IDLE);
2324  if(FLAME_sold_housing_message_board_write == 1 &&
2325  FLAME_sold_housing_message_board_read == 0)
2326  rc = MB_SetAccessMode(b_sold_housing, MB_MODE_WRITEONLY);
2327  if(FLAME_sold_housing_message_board_write == 0 &&
2328  FLAME_sold_housing_message_board_read == 1)
2329  rc = MB_SetAccessMode(b_sold_housing, MB_MODE_READONLY);
2330  if(FLAME_sold_housing_message_board_write == 1 &&
2331  FLAME_sold_housing_message_board_read == 1)
2332  rc = MB_SetAccessMode(b_sold_housing, MB_MODE_READWRITE);
2333  #ifdef ERRCHECK
2334  if (rc != MB_SUCCESS)
2335  {
2336  fprintf(stderr, "ERROR: Could not set access mode of 'sold_housing' board\n");
2337  switch(rc) {
2338  case MB_ERR_INVALID:
2339  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
2340  break;
2341  case MB_ERR_LOCKED:
2342  fprintf(stderr, "\t reason: 'sold_housing' board is locked\n");
2343  break;
2344  case MB_ERR_MEMALLOC:
2345  fprintf(stderr, "\t reason: out of memory\n");
2346  break;
2347  case MB_ERR_INTERNAL:
2348  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2349  break;
2350  default:
2351  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2352  break;
2353  }
2354 
2355  exit(rc);
2356  }
2357  #endif
2358  FLAME_mortgaging_capacity_message_board_write = 0;
2359  FLAME_mortgaging_capacity_message_board_read = 0;
2360  /* Sending agents */
2361  if(bank_start_state->agents != NULL) FLAME_mortgaging_capacity_message_board_write = 1;
2362 
2363  /* Reading agents */
2364  if(reagency_start_state->agents != NULL) FLAME_mortgaging_capacity_message_board_read = 1;
2365 
2366  /* Call message board library with details */
2367  if(FLAME_mortgaging_capacity_message_board_write == 0 &&
2368  FLAME_mortgaging_capacity_message_board_read == 0)
2369  rc = MB_SetAccessMode(b_mortgaging_capacity, MB_MODE_IDLE);
2370  if(FLAME_mortgaging_capacity_message_board_write == 1 &&
2371  FLAME_mortgaging_capacity_message_board_read == 0)
2372  rc = MB_SetAccessMode(b_mortgaging_capacity, MB_MODE_WRITEONLY);
2373  if(FLAME_mortgaging_capacity_message_board_write == 0 &&
2374  FLAME_mortgaging_capacity_message_board_read == 1)
2375  rc = MB_SetAccessMode(b_mortgaging_capacity, MB_MODE_READONLY);
2376  if(FLAME_mortgaging_capacity_message_board_write == 1 &&
2377  FLAME_mortgaging_capacity_message_board_read == 1)
2378  rc = MB_SetAccessMode(b_mortgaging_capacity, MB_MODE_READWRITE);
2379  #ifdef ERRCHECK
2380  if (rc != MB_SUCCESS)
2381  {
2382  fprintf(stderr, "ERROR: Could not set access mode of 'mortgaging_capacity' board\n");
2383  switch(rc) {
2384  case MB_ERR_INVALID:
2385  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is invalid\n");
2386  break;
2387  case MB_ERR_LOCKED:
2388  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is locked\n");
2389  break;
2390  case MB_ERR_MEMALLOC:
2391  fprintf(stderr, "\t reason: out of memory\n");
2392  break;
2393  case MB_ERR_INTERNAL:
2394  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2395  break;
2396  default:
2397  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2398  break;
2399  }
2400 
2401  exit(rc);
2402  }
2403  #endif
2404  FLAME_mortgage_requests_message_board_write = 0;
2405  FLAME_mortgage_requests_message_board_read = 0;
2406  /* Sending agents */
2407  if(reagency_start_state->agents != NULL) FLAME_mortgage_requests_message_board_write = 1;
2408 
2409  /* Reading agents */
2410  if(bank_start_state->agents != NULL) FLAME_mortgage_requests_message_board_read = 1;
2411 
2412  /* Call message board library with details */
2413  if(FLAME_mortgage_requests_message_board_write == 0 &&
2414  FLAME_mortgage_requests_message_board_read == 0)
2415  rc = MB_SetAccessMode(b_mortgage_requests, MB_MODE_IDLE);
2416  if(FLAME_mortgage_requests_message_board_write == 1 &&
2417  FLAME_mortgage_requests_message_board_read == 0)
2418  rc = MB_SetAccessMode(b_mortgage_requests, MB_MODE_WRITEONLY);
2419  if(FLAME_mortgage_requests_message_board_write == 0 &&
2420  FLAME_mortgage_requests_message_board_read == 1)
2421  rc = MB_SetAccessMode(b_mortgage_requests, MB_MODE_READONLY);
2422  if(FLAME_mortgage_requests_message_board_write == 1 &&
2423  FLAME_mortgage_requests_message_board_read == 1)
2424  rc = MB_SetAccessMode(b_mortgage_requests, MB_MODE_READWRITE);
2425  #ifdef ERRCHECK
2426  if (rc != MB_SUCCESS)
2427  {
2428  fprintf(stderr, "ERROR: Could not set access mode of 'mortgage_requests' board\n");
2429  switch(rc) {
2430  case MB_ERR_INVALID:
2431  fprintf(stderr, "\t reason: 'mortgage_requests' board is invalid\n");
2432  break;
2433  case MB_ERR_LOCKED:
2434  fprintf(stderr, "\t reason: 'mortgage_requests' board is locked\n");
2435  break;
2436  case MB_ERR_MEMALLOC:
2437  fprintf(stderr, "\t reason: out of memory\n");
2438  break;
2439  case MB_ERR_INTERNAL:
2440  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2441  break;
2442  default:
2443  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2444  break;
2445  }
2446 
2447  exit(rc);
2448  }
2449  #endif
2450  FLAME_mortgage_payment_from_sale_message_board_write = 0;
2451  FLAME_mortgage_payment_from_sale_message_board_read = 0;
2452  /* Sending agents */
2453  if(household_start_state->agents != NULL) FLAME_mortgage_payment_from_sale_message_board_write = 1;
2454 
2455  /* Reading agents */
2456  if(bank_start_state->agents != NULL) FLAME_mortgage_payment_from_sale_message_board_read = 1;
2457 
2458  /* Call message board library with details */
2459  if(FLAME_mortgage_payment_from_sale_message_board_write == 0 &&
2460  FLAME_mortgage_payment_from_sale_message_board_read == 0)
2461  rc = MB_SetAccessMode(b_mortgage_payment_from_sale, MB_MODE_IDLE);
2462  if(FLAME_mortgage_payment_from_sale_message_board_write == 1 &&
2463  FLAME_mortgage_payment_from_sale_message_board_read == 0)
2464  rc = MB_SetAccessMode(b_mortgage_payment_from_sale, MB_MODE_WRITEONLY);
2465  if(FLAME_mortgage_payment_from_sale_message_board_write == 0 &&
2466  FLAME_mortgage_payment_from_sale_message_board_read == 1)
2467  rc = MB_SetAccessMode(b_mortgage_payment_from_sale, MB_MODE_READONLY);
2468  if(FLAME_mortgage_payment_from_sale_message_board_write == 1 &&
2469  FLAME_mortgage_payment_from_sale_message_board_read == 1)
2470  rc = MB_SetAccessMode(b_mortgage_payment_from_sale, MB_MODE_READWRITE);
2471  #ifdef ERRCHECK
2472  if (rc != MB_SUCCESS)
2473  {
2474  fprintf(stderr, "ERROR: Could not set access mode of 'mortgage_payment_from_sale' board\n");
2475  switch(rc) {
2476  case MB_ERR_INVALID:
2477  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is invalid\n");
2478  break;
2479  case MB_ERR_LOCKED:
2480  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is locked\n");
2481  break;
2482  case MB_ERR_MEMALLOC:
2483  fprintf(stderr, "\t reason: out of memory\n");
2484  break;
2485  case MB_ERR_INTERNAL:
2486  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2487  break;
2488  default:
2489  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2490  break;
2491  }
2492 
2493  exit(rc);
2494  }
2495  #endif
2496  FLAME_mortgage_payment_message_board_write = 0;
2497  FLAME_mortgage_payment_message_board_read = 0;
2498  /* Sending agents */
2499  if(household_start_state->agents != NULL) FLAME_mortgage_payment_message_board_write = 1;
2500 
2501  /* Reading agents */
2502  if(bank_start_state->agents != NULL) FLAME_mortgage_payment_message_board_read = 1;
2503 
2504  /* Call message board library with details */
2505  if(FLAME_mortgage_payment_message_board_write == 0 &&
2506  FLAME_mortgage_payment_message_board_read == 0)
2507  rc = MB_SetAccessMode(b_mortgage_payment, MB_MODE_IDLE);
2508  if(FLAME_mortgage_payment_message_board_write == 1 &&
2509  FLAME_mortgage_payment_message_board_read == 0)
2510  rc = MB_SetAccessMode(b_mortgage_payment, MB_MODE_WRITEONLY);
2511  if(FLAME_mortgage_payment_message_board_write == 0 &&
2512  FLAME_mortgage_payment_message_board_read == 1)
2513  rc = MB_SetAccessMode(b_mortgage_payment, MB_MODE_READONLY);
2514  if(FLAME_mortgage_payment_message_board_write == 1 &&
2515  FLAME_mortgage_payment_message_board_read == 1)
2516  rc = MB_SetAccessMode(b_mortgage_payment, MB_MODE_READWRITE);
2517  #ifdef ERRCHECK
2518  if (rc != MB_SUCCESS)
2519  {
2520  fprintf(stderr, "ERROR: Could not set access mode of 'mortgage_payment' board\n");
2521  switch(rc) {
2522  case MB_ERR_INVALID:
2523  fprintf(stderr, "\t reason: 'mortgage_payment' board is invalid\n");
2524  break;
2525  case MB_ERR_LOCKED:
2526  fprintf(stderr, "\t reason: 'mortgage_payment' board is locked\n");
2527  break;
2528  case MB_ERR_MEMALLOC:
2529  fprintf(stderr, "\t reason: out of memory\n");
2530  break;
2531  case MB_ERR_INTERNAL:
2532  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2533  break;
2534  default:
2535  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2536  break;
2537  }
2538 
2539  exit(rc);
2540  }
2541  #endif
2542  FLAME_mortgage_writeoff_message_board_write = 0;
2543  FLAME_mortgage_writeoff_message_board_read = 0;
2544  /* Sending agents */
2545  if(household_start_state->agents != NULL) FLAME_mortgage_writeoff_message_board_write = 1;
2546 
2547  /* Reading agents */
2548  if(bank_start_state->agents != NULL) FLAME_mortgage_writeoff_message_board_read = 1;
2549 
2550  /* Call message board library with details */
2551  if(FLAME_mortgage_writeoff_message_board_write == 0 &&
2552  FLAME_mortgage_writeoff_message_board_read == 0)
2553  rc = MB_SetAccessMode(b_mortgage_writeoff, MB_MODE_IDLE);
2554  if(FLAME_mortgage_writeoff_message_board_write == 1 &&
2555  FLAME_mortgage_writeoff_message_board_read == 0)
2556  rc = MB_SetAccessMode(b_mortgage_writeoff, MB_MODE_WRITEONLY);
2557  if(FLAME_mortgage_writeoff_message_board_write == 0 &&
2558  FLAME_mortgage_writeoff_message_board_read == 1)
2559  rc = MB_SetAccessMode(b_mortgage_writeoff, MB_MODE_READONLY);
2560  if(FLAME_mortgage_writeoff_message_board_write == 1 &&
2561  FLAME_mortgage_writeoff_message_board_read == 1)
2562  rc = MB_SetAccessMode(b_mortgage_writeoff, MB_MODE_READWRITE);
2563  #ifdef ERRCHECK
2564  if (rc != MB_SUCCESS)
2565  {
2566  fprintf(stderr, "ERROR: Could not set access mode of 'mortgage_writeoff' board\n");
2567  switch(rc) {
2568  case MB_ERR_INVALID:
2569  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is invalid\n");
2570  break;
2571  case MB_ERR_LOCKED:
2572  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is locked\n");
2573  break;
2574  case MB_ERR_MEMALLOC:
2575  fprintf(stderr, "\t reason: out of memory\n");
2576  break;
2577  case MB_ERR_INTERNAL:
2578  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2579  break;
2580  default:
2581  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2582  break;
2583  }
2584 
2585  exit(rc);
2586  }
2587  #endif
2588  FLAME_housing_transactions_summary_message_board_write = 0;
2589  FLAME_housing_transactions_summary_message_board_read = 0;
2590  /* Sending agents */
2591  if(reagency_start_state->agents != NULL) FLAME_housing_transactions_summary_message_board_write = 1;
2592 
2593  /* Reading agents */
2594  if(centralbank_start_state->agents != NULL) FLAME_housing_transactions_summary_message_board_read = 1;
2595 
2596  /* Call message board library with details */
2597  if(FLAME_housing_transactions_summary_message_board_write == 0 &&
2598  FLAME_housing_transactions_summary_message_board_read == 0)
2599  rc = MB_SetAccessMode(b_housing_transactions_summary, MB_MODE_IDLE);
2600  if(FLAME_housing_transactions_summary_message_board_write == 1 &&
2601  FLAME_housing_transactions_summary_message_board_read == 0)
2602  rc = MB_SetAccessMode(b_housing_transactions_summary, MB_MODE_WRITEONLY);
2603  if(FLAME_housing_transactions_summary_message_board_write == 0 &&
2604  FLAME_housing_transactions_summary_message_board_read == 1)
2605  rc = MB_SetAccessMode(b_housing_transactions_summary, MB_MODE_READONLY);
2606  if(FLAME_housing_transactions_summary_message_board_write == 1 &&
2607  FLAME_housing_transactions_summary_message_board_read == 1)
2608  rc = MB_SetAccessMode(b_housing_transactions_summary, MB_MODE_READWRITE);
2609  #ifdef ERRCHECK
2610  if (rc != MB_SUCCESS)
2611  {
2612  fprintf(stderr, "ERROR: Could not set access mode of 'housing_transactions_summary' board\n");
2613  switch(rc) {
2614  case MB_ERR_INVALID:
2615  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is invalid\n");
2616  break;
2617  case MB_ERR_LOCKED:
2618  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is locked\n");
2619  break;
2620  case MB_ERR_MEMALLOC:
2621  fprintf(stderr, "\t reason: out of memory\n");
2622  break;
2623  case MB_ERR_INTERNAL:
2624  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2625  break;
2626  default:
2627  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2628  break;
2629  }
2630 
2631  exit(rc);
2632  }
2633  #endif
2634 
2635 
2636  /* Start timing */
2637  start = get_time();
2638 
2639  for(iteration_loop=iteration_number+1; iteration_loop < iteration_number+iteration_total+1; iteration_loop++)
2640  {
2641  interval = get_time();
2642 
2643  /* Print out iteration number */
2644 
2645  fprintf(stdout, "Iteration - %d\n", iteration_loop);
2646  (void)fflush(stdout);
2647 
2648  /* START OF ITERATION */
2649 
2650  /* Start sync message boards that don't write */
2651  if(FLAME_firm_bank_update_deposit_message_board_write == 0)
2652  {
2653  /*printf("%d> firm_bank_update_deposit message board sync start early as no agents sending any messages of this type\n", node_number);*/
2654 
2655  /* ********** sync message board here ********** */
2656  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_firm_bank_update_deposit)\n");
2657  rc = MB_SyncStart(b_firm_bank_update_deposit);
2658  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_firm_bank_update_deposit)\n");
2659  #ifdef ERRCHECK
2660  if (rc != MB_SUCCESS)
2661  {
2662  fprintf(stderr, "ERROR: Could not start sync of 'firm_bank_update_deposit' board\n");
2663  switch(rc) {
2664  case MB_ERR_INVALID:
2665  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is invalid\n");
2666  break;
2667  case MB_ERR_LOCKED:
2668  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is locked\n");
2669  break;
2670  case MB_ERR_MEMALLOC:
2671  fprintf(stderr, "\t reason: out of memory\n");
2672  break;
2673  case MB_ERR_INTERNAL:
2674  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2675  break;
2676  default:
2677  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2678  break;
2679  }
2680 
2681 
2682  exit(rc);
2683  }
2684  #endif
2685  }
2686 
2687  /* Start sync message boards that don't write */
2688  if(FLAME_household_bank_update_deposit_message_board_write == 0)
2689  {
2690  /*printf("%d> household_bank_update_deposit message board sync start early as no agents sending any messages of this type\n", node_number);*/
2691 
2692  /* ********** sync message board here ********** */
2693  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_household_bank_update_deposit)\n");
2694  rc = MB_SyncStart(b_household_bank_update_deposit);
2695  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_household_bank_update_deposit)\n");
2696  #ifdef ERRCHECK
2697  if (rc != MB_SUCCESS)
2698  {
2699  fprintf(stderr, "ERROR: Could not start sync of 'household_bank_update_deposit' board\n");
2700  switch(rc) {
2701  case MB_ERR_INVALID:
2702  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is invalid\n");
2703  break;
2704  case MB_ERR_LOCKED:
2705  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is locked\n");
2706  break;
2707  case MB_ERR_MEMALLOC:
2708  fprintf(stderr, "\t reason: out of memory\n");
2709  break;
2710  case MB_ERR_INTERNAL:
2711  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2712  break;
2713  default:
2714  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2715  break;
2716  }
2717 
2718 
2719  exit(rc);
2720  }
2721  #endif
2722  }
2723 
2724  /* Start sync message boards that don't write */
2725  if(FLAME_interest_rate_message_board_write == 0)
2726  {
2727  /*printf("%d> interest_rate message board sync start early as no agents sending any messages of this type\n", node_number);*/
2728 
2729  /* ********** sync message board here ********** */
2730  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_interest_rate)\n");
2731  rc = MB_SyncStart(b_interest_rate);
2732  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_interest_rate)\n");
2733  #ifdef ERRCHECK
2734  if (rc != MB_SUCCESS)
2735  {
2736  fprintf(stderr, "ERROR: Could not start sync of 'interest_rate' board\n");
2737  switch(rc) {
2738  case MB_ERR_INVALID:
2739  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
2740  break;
2741  case MB_ERR_LOCKED:
2742  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
2743  break;
2744  case MB_ERR_MEMALLOC:
2745  fprintf(stderr, "\t reason: out of memory\n");
2746  break;
2747  case MB_ERR_INTERNAL:
2748  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2749  break;
2750  default:
2751  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2752  break;
2753  }
2754 
2755 
2756  exit(rc);
2757  }
2758  #endif
2759  }
2760 
2761  /* Start sync message boards that don't write */
2762  if(FLAME_tax_rate_message_board_write == 0)
2763  {
2764  /*printf("%d> tax_rate message board sync start early as no agents sending any messages of this type\n", node_number);*/
2765 
2766  /* ********** sync message board here ********** */
2767  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_tax_rate)\n");
2768  rc = MB_SyncStart(b_tax_rate);
2769  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_tax_rate)\n");
2770  #ifdef ERRCHECK
2771  if (rc != MB_SUCCESS)
2772  {
2773  fprintf(stderr, "ERROR: Could not start sync of 'tax_rate' board\n");
2774  switch(rc) {
2775  case MB_ERR_INVALID:
2776  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
2777  break;
2778  case MB_ERR_LOCKED:
2779  fprintf(stderr, "\t reason: 'tax_rate' board is locked\n");
2780  break;
2781  case MB_ERR_MEMALLOC:
2782  fprintf(stderr, "\t reason: out of memory\n");
2783  break;
2784  case MB_ERR_INTERNAL:
2785  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2786  break;
2787  default:
2788  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2789  break;
2790  }
2791 
2792 
2793  exit(rc);
2794  }
2795  #endif
2796  }
2797 
2798  /* Start sync message boards that don't write */
2799  if(FLAME_buy_message_board_write == 0)
2800  {
2801  /*printf("%d> buy message board sync start early as no agents sending any messages of this type\n", node_number);*/
2802 
2803  /* ********** sync message board here ********** */
2804  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_buy)\n");
2805  rc = MB_SyncStart(b_buy);
2806  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_buy)\n");
2807  #ifdef ERRCHECK
2808  if (rc != MB_SUCCESS)
2809  {
2810  fprintf(stderr, "ERROR: Could not start sync of 'buy' board\n");
2811  switch(rc) {
2812  case MB_ERR_INVALID:
2813  fprintf(stderr, "\t reason: 'buy' board is invalid\n");
2814  break;
2815  case MB_ERR_LOCKED:
2816  fprintf(stderr, "\t reason: 'buy' board is locked\n");
2817  break;
2818  case MB_ERR_MEMALLOC:
2819  fprintf(stderr, "\t reason: out of memory\n");
2820  break;
2821  case MB_ERR_INTERNAL:
2822  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2823  break;
2824  default:
2825  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2826  break;
2827  }
2828 
2829 
2830  exit(rc);
2831  }
2832  #endif
2833  }
2834 
2835  /* Start sync message boards that don't write */
2836  if(FLAME_bought_message_board_write == 0)
2837  {
2838  /*printf("%d> bought message board sync start early as no agents sending any messages of this type\n", node_number);*/
2839 
2840  /* ********** sync message board here ********** */
2841  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bought)\n");
2842  rc = MB_SyncStart(b_bought);
2843  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bought)\n");
2844  #ifdef ERRCHECK
2845  if (rc != MB_SUCCESS)
2846  {
2847  fprintf(stderr, "ERROR: Could not start sync of 'bought' board\n");
2848  switch(rc) {
2849  case MB_ERR_INVALID:
2850  fprintf(stderr, "\t reason: 'bought' board is invalid\n");
2851  break;
2852  case MB_ERR_LOCKED:
2853  fprintf(stderr, "\t reason: 'bought' board is locked\n");
2854  break;
2855  case MB_ERR_MEMALLOC:
2856  fprintf(stderr, "\t reason: out of memory\n");
2857  break;
2858  case MB_ERR_INTERNAL:
2859  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2860  break;
2861  default:
2862  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2863  break;
2864  }
2865 
2866 
2867  exit(rc);
2868  }
2869  #endif
2870  }
2871 
2872  /* Start sync message boards that don't write */
2873  if(FLAME_sell_message_board_write == 0)
2874  {
2875  /*printf("%d> sell message board sync start early as no agents sending any messages of this type\n", node_number);*/
2876 
2877  /* ********** sync message board here ********** */
2878  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sell)\n");
2879  rc = MB_SyncStart(b_sell);
2880  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sell)\n");
2881  #ifdef ERRCHECK
2882  if (rc != MB_SUCCESS)
2883  {
2884  fprintf(stderr, "ERROR: Could not start sync of 'sell' board\n");
2885  switch(rc) {
2886  case MB_ERR_INVALID:
2887  fprintf(stderr, "\t reason: 'sell' board is invalid\n");
2888  break;
2889  case MB_ERR_LOCKED:
2890  fprintf(stderr, "\t reason: 'sell' board is locked\n");
2891  break;
2892  case MB_ERR_MEMALLOC:
2893  fprintf(stderr, "\t reason: out of memory\n");
2894  break;
2895  case MB_ERR_INTERNAL:
2896  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2897  break;
2898  default:
2899  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2900  break;
2901  }
2902 
2903 
2904  exit(rc);
2905  }
2906  #endif
2907  }
2908 
2909  /* Start sync message boards that don't write */
2910  if(FLAME_sold_message_board_write == 0)
2911  {
2912  /*printf("%d> sold message board sync start early as no agents sending any messages of this type\n", node_number);*/
2913 
2914  /* ********** sync message board here ********** */
2915  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sold)\n");
2916  rc = MB_SyncStart(b_sold);
2917  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sold)\n");
2918  #ifdef ERRCHECK
2919  if (rc != MB_SUCCESS)
2920  {
2921  fprintf(stderr, "ERROR: Could not start sync of 'sold' board\n");
2922  switch(rc) {
2923  case MB_ERR_INVALID:
2924  fprintf(stderr, "\t reason: 'sold' board is invalid\n");
2925  break;
2926  case MB_ERR_LOCKED:
2927  fprintf(stderr, "\t reason: 'sold' board is locked\n");
2928  break;
2929  case MB_ERR_MEMALLOC:
2930  fprintf(stderr, "\t reason: out of memory\n");
2931  break;
2932  case MB_ERR_INTERNAL:
2933  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2934  break;
2935  default:
2936  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2937  break;
2938  }
2939 
2940 
2941  exit(rc);
2942  }
2943  #endif
2944  }
2945 
2946  /* Start sync message boards that don't write */
2947  if(FLAME_goods_transactions_summary_message_board_write == 0)
2948  {
2949  /*printf("%d> goods_transactions_summary message board sync start early as no agents sending any messages of this type\n", node_number);*/
2950 
2951  /* ********** sync message board here ********** */
2952  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_goods_transactions_summary)\n");
2953  rc = MB_SyncStart(b_goods_transactions_summary);
2954  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_goods_transactions_summary)\n");
2955  #ifdef ERRCHECK
2956  if (rc != MB_SUCCESS)
2957  {
2958  fprintf(stderr, "ERROR: Could not start sync of 'goods_transactions_summary' board\n");
2959  switch(rc) {
2960  case MB_ERR_INVALID:
2961  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
2962  break;
2963  case MB_ERR_LOCKED:
2964  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is locked\n");
2965  break;
2966  case MB_ERR_MEMALLOC:
2967  fprintf(stderr, "\t reason: out of memory\n");
2968  break;
2969  case MB_ERR_INTERNAL:
2970  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
2971  break;
2972  default:
2973  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
2974  break;
2975  }
2976 
2977 
2978  exit(rc);
2979  }
2980  #endif
2981  }
2982 
2983  /* Start sync message boards that don't write */
2984  if(FLAME_fired_message_board_write == 0)
2985  {
2986  /*printf("%d> fired message board sync start early as no agents sending any messages of this type\n", node_number);*/
2987 
2988  /* ********** sync message board here ********** */
2989  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_fired)\n");
2990  rc = MB_SyncStart(b_fired);
2991  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_fired)\n");
2992  #ifdef ERRCHECK
2993  if (rc != MB_SUCCESS)
2994  {
2995  fprintf(stderr, "ERROR: Could not start sync of 'fired' board\n");
2996  switch(rc) {
2997  case MB_ERR_INVALID:
2998  fprintf(stderr, "\t reason: 'fired' board is invalid\n");
2999  break;
3000  case MB_ERR_LOCKED:
3001  fprintf(stderr, "\t reason: 'fired' board is locked\n");
3002  break;
3003  case MB_ERR_MEMALLOC:
3004  fprintf(stderr, "\t reason: out of memory\n");
3005  break;
3006  case MB_ERR_INTERNAL:
3007  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3008  break;
3009  default:
3010  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3011  break;
3012  }
3013 
3014 
3015  exit(rc);
3016  }
3017  #endif
3018  }
3019 
3020  /* Start sync message boards that don't write */
3021  if(FLAME_vacancy_stage1_message_board_write == 0)
3022  {
3023  /*printf("%d> vacancy_stage1 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3024 
3025  /* ********** sync message board here ********** */
3026  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_vacancy_stage1)\n");
3027  rc = MB_SyncStart(b_vacancy_stage1);
3028  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_vacancy_stage1)\n");
3029  #ifdef ERRCHECK
3030  if (rc != MB_SUCCESS)
3031  {
3032  fprintf(stderr, "ERROR: Could not start sync of 'vacancy_stage1' board\n");
3033  switch(rc) {
3034  case MB_ERR_INVALID:
3035  fprintf(stderr, "\t reason: 'vacancy_stage1' board is invalid\n");
3036  break;
3037  case MB_ERR_LOCKED:
3038  fprintf(stderr, "\t reason: 'vacancy_stage1' board is locked\n");
3039  break;
3040  case MB_ERR_MEMALLOC:
3041  fprintf(stderr, "\t reason: out of memory\n");
3042  break;
3043  case MB_ERR_INTERNAL:
3044  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3045  break;
3046  default:
3047  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3048  break;
3049  }
3050 
3051 
3052  exit(rc);
3053  }
3054  #endif
3055  }
3056 
3057  /* Start sync message boards that don't write */
3058  if(FLAME_job_application_stage2_message_board_write == 0)
3059  {
3060  /*printf("%d> job_application_stage2 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3061 
3062  /* ********** sync message board here ********** */
3063  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_application_stage2)\n");
3064  rc = MB_SyncStart(b_job_application_stage2);
3065  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_application_stage2)\n");
3066  #ifdef ERRCHECK
3067  if (rc != MB_SUCCESS)
3068  {
3069  fprintf(stderr, "ERROR: Could not start sync of 'job_application_stage2' board\n");
3070  switch(rc) {
3071  case MB_ERR_INVALID:
3072  fprintf(stderr, "\t reason: 'job_application_stage2' board is invalid\n");
3073  break;
3074  case MB_ERR_LOCKED:
3075  fprintf(stderr, "\t reason: 'job_application_stage2' board is locked\n");
3076  break;
3077  case MB_ERR_MEMALLOC:
3078  fprintf(stderr, "\t reason: out of memory\n");
3079  break;
3080  case MB_ERR_INTERNAL:
3081  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3082  break;
3083  default:
3084  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3085  break;
3086  }
3087 
3088 
3089  exit(rc);
3090  }
3091  #endif
3092  }
3093 
3094  /* Start sync message boards that don't write */
3095  if(FLAME_job_application_stage1_message_board_write == 0)
3096  {
3097  /*printf("%d> job_application_stage1 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3098 
3099  /* ********** sync message board here ********** */
3100  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_application_stage1)\n");
3101  rc = MB_SyncStart(b_job_application_stage1);
3102  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_application_stage1)\n");
3103  #ifdef ERRCHECK
3104  if (rc != MB_SUCCESS)
3105  {
3106  fprintf(stderr, "ERROR: Could not start sync of 'job_application_stage1' board\n");
3107  switch(rc) {
3108  case MB_ERR_INVALID:
3109  fprintf(stderr, "\t reason: 'job_application_stage1' board is invalid\n");
3110  break;
3111  case MB_ERR_LOCKED:
3112  fprintf(stderr, "\t reason: 'job_application_stage1' board is locked\n");
3113  break;
3114  case MB_ERR_MEMALLOC:
3115  fprintf(stderr, "\t reason: out of memory\n");
3116  break;
3117  case MB_ERR_INTERNAL:
3118  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3119  break;
3120  default:
3121  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3122  break;
3123  }
3124 
3125 
3126  exit(rc);
3127  }
3128  #endif
3129  }
3130 
3131  /* Start sync message boards that don't write */
3132  if(FLAME_job_match_stage1_message_board_write == 0)
3133  {
3134  /*printf("%d> job_match_stage1 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3135 
3136  /* ********** sync message board here ********** */
3137  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_match_stage1)\n");
3138  rc = MB_SyncStart(b_job_match_stage1);
3139  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_match_stage1)\n");
3140  #ifdef ERRCHECK
3141  if (rc != MB_SUCCESS)
3142  {
3143  fprintf(stderr, "ERROR: Could not start sync of 'job_match_stage1' board\n");
3144  switch(rc) {
3145  case MB_ERR_INVALID:
3146  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
3147  break;
3148  case MB_ERR_LOCKED:
3149  fprintf(stderr, "\t reason: 'job_match_stage1' board is locked\n");
3150  break;
3151  case MB_ERR_MEMALLOC:
3152  fprintf(stderr, "\t reason: out of memory\n");
3153  break;
3154  case MB_ERR_INTERNAL:
3155  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3156  break;
3157  default:
3158  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3159  break;
3160  }
3161 
3162 
3163  exit(rc);
3164  }
3165  #endif
3166  }
3167 
3168  /* Start sync message boards that don't write */
3169  if(FLAME_job_change_message_board_write == 0)
3170  {
3171  /*printf("%d> job_change message board sync start early as no agents sending any messages of this type\n", node_number);*/
3172 
3173  /* ********** sync message board here ********** */
3174  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_change)\n");
3175  rc = MB_SyncStart(b_job_change);
3176  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_change)\n");
3177  #ifdef ERRCHECK
3178  if (rc != MB_SUCCESS)
3179  {
3180  fprintf(stderr, "ERROR: Could not start sync of 'job_change' board\n");
3181  switch(rc) {
3182  case MB_ERR_INVALID:
3183  fprintf(stderr, "\t reason: 'job_change' board is invalid\n");
3184  break;
3185  case MB_ERR_LOCKED:
3186  fprintf(stderr, "\t reason: 'job_change' board is locked\n");
3187  break;
3188  case MB_ERR_MEMALLOC:
3189  fprintf(stderr, "\t reason: out of memory\n");
3190  break;
3191  case MB_ERR_INTERNAL:
3192  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3193  break;
3194  default:
3195  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3196  break;
3197  }
3198 
3199 
3200  exit(rc);
3201  }
3202  #endif
3203  }
3204 
3205  /* Start sync message boards that don't write */
3206  if(FLAME_vacancy_stage2_message_board_write == 0)
3207  {
3208  /*printf("%d> vacancy_stage2 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3209 
3210  /* ********** sync message board here ********** */
3211  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_vacancy_stage2)\n");
3212  rc = MB_SyncStart(b_vacancy_stage2);
3213  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_vacancy_stage2)\n");
3214  #ifdef ERRCHECK
3215  if (rc != MB_SUCCESS)
3216  {
3217  fprintf(stderr, "ERROR: Could not start sync of 'vacancy_stage2' board\n");
3218  switch(rc) {
3219  case MB_ERR_INVALID:
3220  fprintf(stderr, "\t reason: 'vacancy_stage2' board is invalid\n");
3221  break;
3222  case MB_ERR_LOCKED:
3223  fprintf(stderr, "\t reason: 'vacancy_stage2' board is locked\n");
3224  break;
3225  case MB_ERR_MEMALLOC:
3226  fprintf(stderr, "\t reason: out of memory\n");
3227  break;
3228  case MB_ERR_INTERNAL:
3229  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3230  break;
3231  default:
3232  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3233  break;
3234  }
3235 
3236 
3237  exit(rc);
3238  }
3239  #endif
3240  }
3241 
3242  /* Start sync message boards that don't write */
3243  if(FLAME_job_match_stage2_message_board_write == 0)
3244  {
3245  /*printf("%d> job_match_stage2 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3246 
3247  /* ********** sync message board here ********** */
3248  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_match_stage2)\n");
3249  rc = MB_SyncStart(b_job_match_stage2);
3250  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_match_stage2)\n");
3251  #ifdef ERRCHECK
3252  if (rc != MB_SUCCESS)
3253  {
3254  fprintf(stderr, "ERROR: Could not start sync of 'job_match_stage2' board\n");
3255  switch(rc) {
3256  case MB_ERR_INVALID:
3257  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
3258  break;
3259  case MB_ERR_LOCKED:
3260  fprintf(stderr, "\t reason: 'job_match_stage2' board is locked\n");
3261  break;
3262  case MB_ERR_MEMALLOC:
3263  fprintf(stderr, "\t reason: out of memory\n");
3264  break;
3265  case MB_ERR_INTERNAL:
3266  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3267  break;
3268  default:
3269  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3270  break;
3271  }
3272 
3273 
3274  exit(rc);
3275  }
3276  #endif
3277  }
3278 
3279  /* Start sync message boards that don't write */
3280  if(FLAME_employment_status_message_board_write == 0)
3281  {
3282  /*printf("%d> employment_status message board sync start early as no agents sending any messages of this type\n", node_number);*/
3283 
3284  /* ********** sync message board here ********** */
3285  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_employment_status)\n");
3286  rc = MB_SyncStart(b_employment_status);
3287  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_employment_status)\n");
3288  #ifdef ERRCHECK
3289  if (rc != MB_SUCCESS)
3290  {
3291  fprintf(stderr, "ERROR: Could not start sync of 'employment_status' board\n");
3292  switch(rc) {
3293  case MB_ERR_INVALID:
3294  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
3295  break;
3296  case MB_ERR_LOCKED:
3297  fprintf(stderr, "\t reason: 'employment_status' board is locked\n");
3298  break;
3299  case MB_ERR_MEMALLOC:
3300  fprintf(stderr, "\t reason: out of memory\n");
3301  break;
3302  case MB_ERR_INTERNAL:
3303  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3304  break;
3305  default:
3306  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3307  break;
3308  }
3309 
3310 
3311  exit(rc);
3312  }
3313  #endif
3314  }
3315 
3316  /* Start sync message boards that don't write */
3317  if(FLAME_loan_request_1_message_board_write == 0)
3318  {
3319  /*printf("%d> loan_request_1 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3320 
3321  /* ********** sync message board here ********** */
3322  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_request_1)\n");
3323  rc = MB_SyncStart(b_loan_request_1);
3324  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_request_1)\n");
3325  #ifdef ERRCHECK
3326  if (rc != MB_SUCCESS)
3327  {
3328  fprintf(stderr, "ERROR: Could not start sync of 'loan_request_1' board\n");
3329  switch(rc) {
3330  case MB_ERR_INVALID:
3331  fprintf(stderr, "\t reason: 'loan_request_1' board is invalid\n");
3332  break;
3333  case MB_ERR_LOCKED:
3334  fprintf(stderr, "\t reason: 'loan_request_1' board is locked\n");
3335  break;
3336  case MB_ERR_MEMALLOC:
3337  fprintf(stderr, "\t reason: out of memory\n");
3338  break;
3339  case MB_ERR_INTERNAL:
3340  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3341  break;
3342  default:
3343  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3344  break;
3345  }
3346 
3347 
3348  exit(rc);
3349  }
3350  #endif
3351  }
3352 
3353  /* Start sync message boards that don't write */
3354  if(FLAME_loan_request_2_message_board_write == 0)
3355  {
3356  /*printf("%d> loan_request_2 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3357 
3358  /* ********** sync message board here ********** */
3359  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_request_2)\n");
3360  rc = MB_SyncStart(b_loan_request_2);
3361  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_request_2)\n");
3362  #ifdef ERRCHECK
3363  if (rc != MB_SUCCESS)
3364  {
3365  fprintf(stderr, "ERROR: Could not start sync of 'loan_request_2' board\n");
3366  switch(rc) {
3367  case MB_ERR_INVALID:
3368  fprintf(stderr, "\t reason: 'loan_request_2' board is invalid\n");
3369  break;
3370  case MB_ERR_LOCKED:
3371  fprintf(stderr, "\t reason: 'loan_request_2' board is locked\n");
3372  break;
3373  case MB_ERR_MEMALLOC:
3374  fprintf(stderr, "\t reason: out of memory\n");
3375  break;
3376  case MB_ERR_INTERNAL:
3377  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3378  break;
3379  default:
3380  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3381  break;
3382  }
3383 
3384 
3385  exit(rc);
3386  }
3387  #endif
3388  }
3389 
3390  /* Start sync message boards that don't write */
3391  if(FLAME_loan_acknowledge_1_message_board_write == 0)
3392  {
3393  /*printf("%d> loan_acknowledge_1 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3394 
3395  /* ********** sync message board here ********** */
3396  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_acknowledge_1)\n");
3397  rc = MB_SyncStart(b_loan_acknowledge_1);
3398  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_acknowledge_1)\n");
3399  #ifdef ERRCHECK
3400  if (rc != MB_SUCCESS)
3401  {
3402  fprintf(stderr, "ERROR: Could not start sync of 'loan_acknowledge_1' board\n");
3403  switch(rc) {
3404  case MB_ERR_INVALID:
3405  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is invalid\n");
3406  break;
3407  case MB_ERR_LOCKED:
3408  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is locked\n");
3409  break;
3410  case MB_ERR_MEMALLOC:
3411  fprintf(stderr, "\t reason: out of memory\n");
3412  break;
3413  case MB_ERR_INTERNAL:
3414  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3415  break;
3416  default:
3417  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3418  break;
3419  }
3420 
3421 
3422  exit(rc);
3423  }
3424  #endif
3425  }
3426 
3427  /* Start sync message boards that don't write */
3428  if(FLAME_loan_acknowledge_2_message_board_write == 0)
3429  {
3430  /*printf("%d> loan_acknowledge_2 message board sync start early as no agents sending any messages of this type\n", node_number);*/
3431 
3432  /* ********** sync message board here ********** */
3433  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_acknowledge_2)\n");
3434  rc = MB_SyncStart(b_loan_acknowledge_2);
3435  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_acknowledge_2)\n");
3436  #ifdef ERRCHECK
3437  if (rc != MB_SUCCESS)
3438  {
3439  fprintf(stderr, "ERROR: Could not start sync of 'loan_acknowledge_2' board\n");
3440  switch(rc) {
3441  case MB_ERR_INVALID:
3442  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is invalid\n");
3443  break;
3444  case MB_ERR_LOCKED:
3445  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is locked\n");
3446  break;
3447  case MB_ERR_MEMALLOC:
3448  fprintf(stderr, "\t reason: out of memory\n");
3449  break;
3450  case MB_ERR_INTERNAL:
3451  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3452  break;
3453  default:
3454  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3455  break;
3456  }
3457 
3458 
3459  exit(rc);
3460  }
3461  #endif
3462  }
3463 
3464  /* Start sync message boards that don't write */
3465  if(FLAME_debt_request_message_board_write == 0)
3466  {
3467  /*printf("%d> debt_request message board sync start early as no agents sending any messages of this type\n", node_number);*/
3468 
3469  /* ********** sync message board here ********** */
3470  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_debt_request)\n");
3471  rc = MB_SyncStart(b_debt_request);
3472  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_debt_request)\n");
3473  #ifdef ERRCHECK
3474  if (rc != MB_SUCCESS)
3475  {
3476  fprintf(stderr, "ERROR: Could not start sync of 'debt_request' board\n");
3477  switch(rc) {
3478  case MB_ERR_INVALID:
3479  fprintf(stderr, "\t reason: 'debt_request' board is invalid\n");
3480  break;
3481  case MB_ERR_LOCKED:
3482  fprintf(stderr, "\t reason: 'debt_request' board is locked\n");
3483  break;
3484  case MB_ERR_MEMALLOC:
3485  fprintf(stderr, "\t reason: out of memory\n");
3486  break;
3487  case MB_ERR_INTERNAL:
3488  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3489  break;
3490  default:
3491  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3492  break;
3493  }
3494 
3495 
3496  exit(rc);
3497  }
3498  #endif
3499  }
3500 
3501  /* Start sync message boards that don't write */
3502  if(FLAME_household_share_message_board_write == 0)
3503  {
3504  /*printf("%d> household_share message board sync start early as no agents sending any messages of this type\n", node_number);*/
3505 
3506  /* ********** sync message board here ********** */
3507  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_household_share)\n");
3508  rc = MB_SyncStart(b_household_share);
3509  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_household_share)\n");
3510  #ifdef ERRCHECK
3511  if (rc != MB_SUCCESS)
3512  {
3513  fprintf(stderr, "ERROR: Could not start sync of 'household_share' board\n");
3514  switch(rc) {
3515  case MB_ERR_INVALID:
3516  fprintf(stderr, "\t reason: 'household_share' board is invalid\n");
3517  break;
3518  case MB_ERR_LOCKED:
3519  fprintf(stderr, "\t reason: 'household_share' board is locked\n");
3520  break;
3521  case MB_ERR_MEMALLOC:
3522  fprintf(stderr, "\t reason: out of memory\n");
3523  break;
3524  case MB_ERR_INTERNAL:
3525  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3526  break;
3527  default:
3528  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3529  break;
3530  }
3531 
3532 
3533  exit(rc);
3534  }
3535  #endif
3536  }
3537 
3538  /* Start sync message boards that don't write */
3539  if(FLAME_capital_tax_message_board_write == 0)
3540  {
3541  /*printf("%d> capital_tax message board sync start early as no agents sending any messages of this type\n", node_number);*/
3542 
3543  /* ********** sync message board here ********** */
3544  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_capital_tax)\n");
3545  rc = MB_SyncStart(b_capital_tax);
3546  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_capital_tax)\n");
3547  #ifdef ERRCHECK
3548  if (rc != MB_SUCCESS)
3549  {
3550  fprintf(stderr, "ERROR: Could not start sync of 'capital_tax' board\n");
3551  switch(rc) {
3552  case MB_ERR_INVALID:
3553  fprintf(stderr, "\t reason: 'capital_tax' board is invalid\n");
3554  break;
3555  case MB_ERR_LOCKED:
3556  fprintf(stderr, "\t reason: 'capital_tax' board is locked\n");
3557  break;
3558  case MB_ERR_MEMALLOC:
3559  fprintf(stderr, "\t reason: out of memory\n");
3560  break;
3561  case MB_ERR_INTERNAL:
3562  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3563  break;
3564  default:
3565  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3566  break;
3567  }
3568 
3569 
3570  exit(rc);
3571  }
3572  #endif
3573  }
3574 
3575  /* Start sync message boards that don't write */
3576  if(FLAME_labour_tax_message_board_write == 0)
3577  {
3578  /*printf("%d> labour_tax message board sync start early as no agents sending any messages of this type\n", node_number);*/
3579 
3580  /* ********** sync message board here ********** */
3581  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_labour_tax)\n");
3582  rc = MB_SyncStart(b_labour_tax);
3583  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_labour_tax)\n");
3584  #ifdef ERRCHECK
3585  if (rc != MB_SUCCESS)
3586  {
3587  fprintf(stderr, "ERROR: Could not start sync of 'labour_tax' board\n");
3588  switch(rc) {
3589  case MB_ERR_INVALID:
3590  fprintf(stderr, "\t reason: 'labour_tax' board is invalid\n");
3591  break;
3592  case MB_ERR_LOCKED:
3593  fprintf(stderr, "\t reason: 'labour_tax' board is locked\n");
3594  break;
3595  case MB_ERR_MEMALLOC:
3596  fprintf(stderr, "\t reason: out of memory\n");
3597  break;
3598  case MB_ERR_INTERNAL:
3599  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3600  break;
3601  default:
3602  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3603  break;
3604  }
3605 
3606 
3607  exit(rc);
3608  }
3609  #endif
3610  }
3611 
3612  /* Start sync message boards that don't write */
3613  if(FLAME_unemployment_benefit_message_board_write == 0)
3614  {
3615  /*printf("%d> unemployment_benefit message board sync start early as no agents sending any messages of this type\n", node_number);*/
3616 
3617  /* ********** sync message board here ********** */
3618  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_unemployment_benefit)\n");
3619  rc = MB_SyncStart(b_unemployment_benefit);
3620  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_unemployment_benefit)\n");
3621  #ifdef ERRCHECK
3622  if (rc != MB_SUCCESS)
3623  {
3624  fprintf(stderr, "ERROR: Could not start sync of 'unemployment_benefit' board\n");
3625  switch(rc) {
3626  case MB_ERR_INVALID:
3627  fprintf(stderr, "\t reason: 'unemployment_benefit' board is invalid\n");
3628  break;
3629  case MB_ERR_LOCKED:
3630  fprintf(stderr, "\t reason: 'unemployment_benefit' board is locked\n");
3631  break;
3632  case MB_ERR_MEMALLOC:
3633  fprintf(stderr, "\t reason: out of memory\n");
3634  break;
3635  case MB_ERR_INTERNAL:
3636  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3637  break;
3638  default:
3639  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3640  break;
3641  }
3642 
3643 
3644  exit(rc);
3645  }
3646  #endif
3647  }
3648 
3649  /* Start sync message boards that don't write */
3650  if(FLAME_general_benefit_message_board_write == 0)
3651  {
3652  /*printf("%d> general_benefit message board sync start early as no agents sending any messages of this type\n", node_number);*/
3653 
3654  /* ********** sync message board here ********** */
3655  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_general_benefit)\n");
3656  rc = MB_SyncStart(b_general_benefit);
3657  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_general_benefit)\n");
3658  #ifdef ERRCHECK
3659  if (rc != MB_SUCCESS)
3660  {
3661  fprintf(stderr, "ERROR: Could not start sync of 'general_benefit' board\n");
3662  switch(rc) {
3663  case MB_ERR_INVALID:
3664  fprintf(stderr, "\t reason: 'general_benefit' board is invalid\n");
3665  break;
3666  case MB_ERR_LOCKED:
3667  fprintf(stderr, "\t reason: 'general_benefit' board is locked\n");
3668  break;
3669  case MB_ERR_MEMALLOC:
3670  fprintf(stderr, "\t reason: out of memory\n");
3671  break;
3672  case MB_ERR_INTERNAL:
3673  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3674  break;
3675  default:
3676  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3677  break;
3678  }
3679 
3680 
3681  exit(rc);
3682  }
3683  #endif
3684  }
3685 
3686  /* Start sync message boards that don't write */
3687  if(FLAME_fund_request_message_board_write == 0)
3688  {
3689  /*printf("%d> fund_request message board sync start early as no agents sending any messages of this type\n", node_number);*/
3690 
3691  /* ********** sync message board here ********** */
3692  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_fund_request)\n");
3693  rc = MB_SyncStart(b_fund_request);
3694  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_fund_request)\n");
3695  #ifdef ERRCHECK
3696  if (rc != MB_SUCCESS)
3697  {
3698  fprintf(stderr, "ERROR: Could not start sync of 'fund_request' board\n");
3699  switch(rc) {
3700  case MB_ERR_INVALID:
3701  fprintf(stderr, "\t reason: 'fund_request' board is invalid\n");
3702  break;
3703  case MB_ERR_LOCKED:
3704  fprintf(stderr, "\t reason: 'fund_request' board is locked\n");
3705  break;
3706  case MB_ERR_MEMALLOC:
3707  fprintf(stderr, "\t reason: out of memory\n");
3708  break;
3709  case MB_ERR_INTERNAL:
3710  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3711  break;
3712  default:
3713  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3714  break;
3715  }
3716 
3717 
3718  exit(rc);
3719  }
3720  #endif
3721  }
3722 
3723  /* Start sync message boards that don't write */
3724  if(FLAME_fund_request_ack_message_board_write == 0)
3725  {
3726  /*printf("%d> fund_request_ack message board sync start early as no agents sending any messages of this type\n", node_number);*/
3727 
3728  /* ********** sync message board here ********** */
3729  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_fund_request_ack)\n");
3730  rc = MB_SyncStart(b_fund_request_ack);
3731  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_fund_request_ack)\n");
3732  #ifdef ERRCHECK
3733  if (rc != MB_SUCCESS)
3734  {
3735  fprintf(stderr, "ERROR: Could not start sync of 'fund_request_ack' board\n");
3736  switch(rc) {
3737  case MB_ERR_INVALID:
3738  fprintf(stderr, "\t reason: 'fund_request_ack' board is invalid\n");
3739  break;
3740  case MB_ERR_LOCKED:
3741  fprintf(stderr, "\t reason: 'fund_request_ack' board is locked\n");
3742  break;
3743  case MB_ERR_MEMALLOC:
3744  fprintf(stderr, "\t reason: out of memory\n");
3745  break;
3746  case MB_ERR_INTERNAL:
3747  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3748  break;
3749  default:
3750  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3751  break;
3752  }
3753 
3754 
3755  exit(rc);
3756  }
3757  #endif
3758  }
3759 
3760  /* Start sync message boards that don't write */
3761  if(FLAME_new_entrant_loan_message_board_write == 0)
3762  {
3763  /*printf("%d> new_entrant_loan message board sync start early as no agents sending any messages of this type\n", node_number);*/
3764 
3765  /* ********** sync message board here ********** */
3766  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_new_entrant_loan)\n");
3767  rc = MB_SyncStart(b_new_entrant_loan);
3768  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_new_entrant_loan)\n");
3769  #ifdef ERRCHECK
3770  if (rc != MB_SUCCESS)
3771  {
3772  fprintf(stderr, "ERROR: Could not start sync of 'new_entrant_loan' board\n");
3773  switch(rc) {
3774  case MB_ERR_INVALID:
3775  fprintf(stderr, "\t reason: 'new_entrant_loan' board is invalid\n");
3776  break;
3777  case MB_ERR_LOCKED:
3778  fprintf(stderr, "\t reason: 'new_entrant_loan' board is locked\n");
3779  break;
3780  case MB_ERR_MEMALLOC:
3781  fprintf(stderr, "\t reason: out of memory\n");
3782  break;
3783  case MB_ERR_INTERNAL:
3784  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3785  break;
3786  default:
3787  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3788  break;
3789  }
3790 
3791 
3792  exit(rc);
3793  }
3794  #endif
3795  }
3796 
3797  /* Start sync message boards that don't write */
3798  if(FLAME_interest_on_loan_message_board_write == 0)
3799  {
3800  /*printf("%d> interest_on_loan message board sync start early as no agents sending any messages of this type\n", node_number);*/
3801 
3802  /* ********** sync message board here ********** */
3803  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_interest_on_loan)\n");
3804  rc = MB_SyncStart(b_interest_on_loan);
3805  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_interest_on_loan)\n");
3806  #ifdef ERRCHECK
3807  if (rc != MB_SUCCESS)
3808  {
3809  fprintf(stderr, "ERROR: Could not start sync of 'interest_on_loan' board\n");
3810  switch(rc) {
3811  case MB_ERR_INVALID:
3812  fprintf(stderr, "\t reason: 'interest_on_loan' board is invalid\n");
3813  break;
3814  case MB_ERR_LOCKED:
3815  fprintf(stderr, "\t reason: 'interest_on_loan' board is locked\n");
3816  break;
3817  case MB_ERR_MEMALLOC:
3818  fprintf(stderr, "\t reason: out of memory\n");
3819  break;
3820  case MB_ERR_INTERNAL:
3821  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3822  break;
3823  default:
3824  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3825  break;
3826  }
3827 
3828 
3829  exit(rc);
3830  }
3831  #endif
3832  }
3833 
3834  /* Start sync message boards that don't write */
3835  if(FLAME_loan_writeoff_message_board_write == 0)
3836  {
3837  /*printf("%d> loan_writeoff message board sync start early as no agents sending any messages of this type\n", node_number);*/
3838 
3839  /* ********** sync message board here ********** */
3840  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_writeoff)\n");
3841  rc = MB_SyncStart(b_loan_writeoff);
3842  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_writeoff)\n");
3843  #ifdef ERRCHECK
3844  if (rc != MB_SUCCESS)
3845  {
3846  fprintf(stderr, "ERROR: Could not start sync of 'loan_writeoff' board\n");
3847  switch(rc) {
3848  case MB_ERR_INVALID:
3849  fprintf(stderr, "\t reason: 'loan_writeoff' board is invalid\n");
3850  break;
3851  case MB_ERR_LOCKED:
3852  fprintf(stderr, "\t reason: 'loan_writeoff' board is locked\n");
3853  break;
3854  case MB_ERR_MEMALLOC:
3855  fprintf(stderr, "\t reason: out of memory\n");
3856  break;
3857  case MB_ERR_INTERNAL:
3858  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3859  break;
3860  default:
3861  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3862  break;
3863  }
3864 
3865 
3866  exit(rc);
3867  }
3868  #endif
3869  }
3870 
3871  /* Start sync message boards that don't write */
3872  if(FLAME_firm_net_profit_message_board_write == 0)
3873  {
3874  /*printf("%d> firm_net_profit message board sync start early as no agents sending any messages of this type\n", node_number);*/
3875 
3876  /* ********** sync message board here ********** */
3877  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_firm_net_profit)\n");
3878  rc = MB_SyncStart(b_firm_net_profit);
3879  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_firm_net_profit)\n");
3880  #ifdef ERRCHECK
3881  if (rc != MB_SUCCESS)
3882  {
3883  fprintf(stderr, "ERROR: Could not start sync of 'firm_net_profit' board\n");
3884  switch(rc) {
3885  case MB_ERR_INVALID:
3886  fprintf(stderr, "\t reason: 'firm_net_profit' board is invalid\n");
3887  break;
3888  case MB_ERR_LOCKED:
3889  fprintf(stderr, "\t reason: 'firm_net_profit' board is locked\n");
3890  break;
3891  case MB_ERR_MEMALLOC:
3892  fprintf(stderr, "\t reason: out of memory\n");
3893  break;
3894  case MB_ERR_INTERNAL:
3895  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3896  break;
3897  default:
3898  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3899  break;
3900  }
3901 
3902 
3903  exit(rc);
3904  }
3905  #endif
3906  }
3907 
3908  /* Start sync message boards that don't write */
3909  if(FLAME_bank_net_profit_message_board_write == 0)
3910  {
3911  /*printf("%d> bank_net_profit message board sync start early as no agents sending any messages of this type\n", node_number);*/
3912 
3913  /* ********** sync message board here ********** */
3914  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bank_net_profit)\n");
3915  rc = MB_SyncStart(b_bank_net_profit);
3916  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bank_net_profit)\n");
3917  #ifdef ERRCHECK
3918  if (rc != MB_SUCCESS)
3919  {
3920  fprintf(stderr, "ERROR: Could not start sync of 'bank_net_profit' board\n");
3921  switch(rc) {
3922  case MB_ERR_INVALID:
3923  fprintf(stderr, "\t reason: 'bank_net_profit' board is invalid\n");
3924  break;
3925  case MB_ERR_LOCKED:
3926  fprintf(stderr, "\t reason: 'bank_net_profit' board is locked\n");
3927  break;
3928  case MB_ERR_MEMALLOC:
3929  fprintf(stderr, "\t reason: out of memory\n");
3930  break;
3931  case MB_ERR_INTERNAL:
3932  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3933  break;
3934  default:
3935  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3936  break;
3937  }
3938 
3939 
3940  exit(rc);
3941  }
3942  #endif
3943  }
3944 
3945  /* Start sync message boards that don't write */
3946  if(FLAME_bank_centralbank_interest_payment_message_board_write == 0)
3947  {
3948  /*printf("%d> bank_centralbank_interest_payment message board sync start early as no agents sending any messages of this type\n", node_number);*/
3949 
3950  /* ********** sync message board here ********** */
3951  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bank_centralbank_interest_payment)\n");
3952  rc = MB_SyncStart(b_bank_centralbank_interest_payment);
3953  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bank_centralbank_interest_payment)\n");
3954  #ifdef ERRCHECK
3955  if (rc != MB_SUCCESS)
3956  {
3957  fprintf(stderr, "ERROR: Could not start sync of 'bank_centralbank_interest_payment' board\n");
3958  switch(rc) {
3959  case MB_ERR_INVALID:
3960  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is invalid\n");
3961  break;
3962  case MB_ERR_LOCKED:
3963  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is locked\n");
3964  break;
3965  case MB_ERR_MEMALLOC:
3966  fprintf(stderr, "\t reason: out of memory\n");
3967  break;
3968  case MB_ERR_INTERNAL:
3969  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
3970  break;
3971  default:
3972  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
3973  break;
3974  }
3975 
3976 
3977  exit(rc);
3978  }
3979  #endif
3980  }
3981 
3982  /* Start sync message boards that don't write */
3983  if(FLAME_bank_centralbank_debt_payment_message_board_write == 0)
3984  {
3985  /*printf("%d> bank_centralbank_debt_payment message board sync start early as no agents sending any messages of this type\n", node_number);*/
3986 
3987  /* ********** sync message board here ********** */
3988  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bank_centralbank_debt_payment)\n");
3989  rc = MB_SyncStart(b_bank_centralbank_debt_payment);
3990  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bank_centralbank_debt_payment)\n");
3991  #ifdef ERRCHECK
3992  if (rc != MB_SUCCESS)
3993  {
3994  fprintf(stderr, "ERROR: Could not start sync of 'bank_centralbank_debt_payment' board\n");
3995  switch(rc) {
3996  case MB_ERR_INVALID:
3997  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is invalid\n");
3998  break;
3999  case MB_ERR_LOCKED:
4000  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is locked\n");
4001  break;
4002  case MB_ERR_MEMALLOC:
4003  fprintf(stderr, "\t reason: out of memory\n");
4004  break;
4005  case MB_ERR_INTERNAL:
4006  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4007  break;
4008  default:
4009  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4010  break;
4011  }
4012 
4013 
4014  exit(rc);
4015  }
4016  #endif
4017  }
4018 
4019  /* Start sync message boards that don't write */
4020  if(FLAME_centralbank_government_profit_message_board_write == 0)
4021  {
4022  /*printf("%d> centralbank_government_profit message board sync start early as no agents sending any messages of this type\n", node_number);*/
4023 
4024  /* ********** sync message board here ********** */
4025  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_centralbank_government_profit)\n");
4026  rc = MB_SyncStart(b_centralbank_government_profit);
4027  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_centralbank_government_profit)\n");
4028  #ifdef ERRCHECK
4029  if (rc != MB_SUCCESS)
4030  {
4031  fprintf(stderr, "ERROR: Could not start sync of 'centralbank_government_profit' board\n");
4032  switch(rc) {
4033  case MB_ERR_INVALID:
4034  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is invalid\n");
4035  break;
4036  case MB_ERR_LOCKED:
4037  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is locked\n");
4038  break;
4039  case MB_ERR_MEMALLOC:
4040  fprintf(stderr, "\t reason: out of memory\n");
4041  break;
4042  case MB_ERR_INTERNAL:
4043  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4044  break;
4045  default:
4046  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4047  break;
4048  }
4049 
4050 
4051  exit(rc);
4052  }
4053  #endif
4054  }
4055 
4056  /* Start sync message boards that don't write */
4057  if(FLAME_housing_price_message_board_write == 0)
4058  {
4059  /*printf("%d> housing_price message board sync start early as no agents sending any messages of this type\n", node_number);*/
4060 
4061  /* ********** sync message board here ********** */
4062  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_housing_price)\n");
4063  rc = MB_SyncStart(b_housing_price);
4064  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_housing_price)\n");
4065  #ifdef ERRCHECK
4066  if (rc != MB_SUCCESS)
4067  {
4068  fprintf(stderr, "ERROR: Could not start sync of 'housing_price' board\n");
4069  switch(rc) {
4070  case MB_ERR_INVALID:
4071  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
4072  break;
4073  case MB_ERR_LOCKED:
4074  fprintf(stderr, "\t reason: 'housing_price' board is locked\n");
4075  break;
4076  case MB_ERR_MEMALLOC:
4077  fprintf(stderr, "\t reason: out of memory\n");
4078  break;
4079  case MB_ERR_INTERNAL:
4080  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4081  break;
4082  default:
4083  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4084  break;
4085  }
4086 
4087 
4088  exit(rc);
4089  }
4090  #endif
4091  }
4092 
4093  /* Start sync message boards that don't write */
4094  if(FLAME_buy_housing_message_board_write == 0)
4095  {
4096  /*printf("%d> buy_housing message board sync start early as no agents sending any messages of this type\n", node_number);*/
4097 
4098  /* ********** sync message board here ********** */
4099  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_buy_housing)\n");
4100  rc = MB_SyncStart(b_buy_housing);
4101  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_buy_housing)\n");
4102  #ifdef ERRCHECK
4103  if (rc != MB_SUCCESS)
4104  {
4105  fprintf(stderr, "ERROR: Could not start sync of 'buy_housing' board\n");
4106  switch(rc) {
4107  case MB_ERR_INVALID:
4108  fprintf(stderr, "\t reason: 'buy_housing' board is invalid\n");
4109  break;
4110  case MB_ERR_LOCKED:
4111  fprintf(stderr, "\t reason: 'buy_housing' board is locked\n");
4112  break;
4113  case MB_ERR_MEMALLOC:
4114  fprintf(stderr, "\t reason: out of memory\n");
4115  break;
4116  case MB_ERR_INTERNAL:
4117  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4118  break;
4119  default:
4120  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4121  break;
4122  }
4123 
4124 
4125  exit(rc);
4126  }
4127  #endif
4128  }
4129 
4130  /* Start sync message boards that don't write */
4131  if(FLAME_sell_housing_message_board_write == 0)
4132  {
4133  /*printf("%d> sell_housing message board sync start early as no agents sending any messages of this type\n", node_number);*/
4134 
4135  /* ********** sync message board here ********** */
4136  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sell_housing)\n");
4137  rc = MB_SyncStart(b_sell_housing);
4138  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sell_housing)\n");
4139  #ifdef ERRCHECK
4140  if (rc != MB_SUCCESS)
4141  {
4142  fprintf(stderr, "ERROR: Could not start sync of 'sell_housing' board\n");
4143  switch(rc) {
4144  case MB_ERR_INVALID:
4145  fprintf(stderr, "\t reason: 'sell_housing' board is invalid\n");
4146  break;
4147  case MB_ERR_LOCKED:
4148  fprintf(stderr, "\t reason: 'sell_housing' board is locked\n");
4149  break;
4150  case MB_ERR_MEMALLOC:
4151  fprintf(stderr, "\t reason: out of memory\n");
4152  break;
4153  case MB_ERR_INTERNAL:
4154  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4155  break;
4156  default:
4157  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4158  break;
4159  }
4160 
4161 
4162  exit(rc);
4163  }
4164  #endif
4165  }
4166 
4167  /* Start sync message boards that don't write */
4168  if(FLAME_bought_housing_message_board_write == 0)
4169  {
4170  /*printf("%d> bought_housing message board sync start early as no agents sending any messages of this type\n", node_number);*/
4171 
4172  /* ********** sync message board here ********** */
4173  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bought_housing)\n");
4174  rc = MB_SyncStart(b_bought_housing);
4175  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bought_housing)\n");
4176  #ifdef ERRCHECK
4177  if (rc != MB_SUCCESS)
4178  {
4179  fprintf(stderr, "ERROR: Could not start sync of 'bought_housing' board\n");
4180  switch(rc) {
4181  case MB_ERR_INVALID:
4182  fprintf(stderr, "\t reason: 'bought_housing' board is invalid\n");
4183  break;
4184  case MB_ERR_LOCKED:
4185  fprintf(stderr, "\t reason: 'bought_housing' board is locked\n");
4186  break;
4187  case MB_ERR_MEMALLOC:
4188  fprintf(stderr, "\t reason: out of memory\n");
4189  break;
4190  case MB_ERR_INTERNAL:
4191  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4192  break;
4193  default:
4194  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4195  break;
4196  }
4197 
4198 
4199  exit(rc);
4200  }
4201  #endif
4202  }
4203 
4204  /* Start sync message boards that don't write */
4205  if(FLAME_sold_housing_message_board_write == 0)
4206  {
4207  /*printf("%d> sold_housing message board sync start early as no agents sending any messages of this type\n", node_number);*/
4208 
4209  /* ********** sync message board here ********** */
4210  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sold_housing)\n");
4211  rc = MB_SyncStart(b_sold_housing);
4212  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sold_housing)\n");
4213  #ifdef ERRCHECK
4214  if (rc != MB_SUCCESS)
4215  {
4216  fprintf(stderr, "ERROR: Could not start sync of 'sold_housing' board\n");
4217  switch(rc) {
4218  case MB_ERR_INVALID:
4219  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
4220  break;
4221  case MB_ERR_LOCKED:
4222  fprintf(stderr, "\t reason: 'sold_housing' board is locked\n");
4223  break;
4224  case MB_ERR_MEMALLOC:
4225  fprintf(stderr, "\t reason: out of memory\n");
4226  break;
4227  case MB_ERR_INTERNAL:
4228  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4229  break;
4230  default:
4231  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4232  break;
4233  }
4234 
4235 
4236  exit(rc);
4237  }
4238  #endif
4239  }
4240 
4241  /* Start sync message boards that don't write */
4242  if(FLAME_mortgaging_capacity_message_board_write == 0)
4243  {
4244  /*printf("%d> mortgaging_capacity message board sync start early as no agents sending any messages of this type\n", node_number);*/
4245 
4246  /* ********** sync message board here ********** */
4247  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgaging_capacity)\n");
4248  rc = MB_SyncStart(b_mortgaging_capacity);
4249  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgaging_capacity)\n");
4250  #ifdef ERRCHECK
4251  if (rc != MB_SUCCESS)
4252  {
4253  fprintf(stderr, "ERROR: Could not start sync of 'mortgaging_capacity' board\n");
4254  switch(rc) {
4255  case MB_ERR_INVALID:
4256  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is invalid\n");
4257  break;
4258  case MB_ERR_LOCKED:
4259  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is locked\n");
4260  break;
4261  case MB_ERR_MEMALLOC:
4262  fprintf(stderr, "\t reason: out of memory\n");
4263  break;
4264  case MB_ERR_INTERNAL:
4265  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4266  break;
4267  default:
4268  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4269  break;
4270  }
4271 
4272 
4273  exit(rc);
4274  }
4275  #endif
4276  }
4277 
4278  /* Start sync message boards that don't write */
4279  if(FLAME_mortgage_requests_message_board_write == 0)
4280  {
4281  /*printf("%d> mortgage_requests message board sync start early as no agents sending any messages of this type\n", node_number);*/
4282 
4283  /* ********** sync message board here ********** */
4284  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_requests)\n");
4285  rc = MB_SyncStart(b_mortgage_requests);
4286  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_requests)\n");
4287  #ifdef ERRCHECK
4288  if (rc != MB_SUCCESS)
4289  {
4290  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_requests' board\n");
4291  switch(rc) {
4292  case MB_ERR_INVALID:
4293  fprintf(stderr, "\t reason: 'mortgage_requests' board is invalid\n");
4294  break;
4295  case MB_ERR_LOCKED:
4296  fprintf(stderr, "\t reason: 'mortgage_requests' board is locked\n");
4297  break;
4298  case MB_ERR_MEMALLOC:
4299  fprintf(stderr, "\t reason: out of memory\n");
4300  break;
4301  case MB_ERR_INTERNAL:
4302  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4303  break;
4304  default:
4305  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4306  break;
4307  }
4308 
4309 
4310  exit(rc);
4311  }
4312  #endif
4313  }
4314 
4315  /* Start sync message boards that don't write */
4316  if(FLAME_mortgage_payment_from_sale_message_board_write == 0)
4317  {
4318  /*printf("%d> mortgage_payment_from_sale message board sync start early as no agents sending any messages of this type\n", node_number);*/
4319 
4320  /* ********** sync message board here ********** */
4321  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_payment_from_sale)\n");
4322  rc = MB_SyncStart(b_mortgage_payment_from_sale);
4323  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_payment_from_sale)\n");
4324  #ifdef ERRCHECK
4325  if (rc != MB_SUCCESS)
4326  {
4327  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_payment_from_sale' board\n");
4328  switch(rc) {
4329  case MB_ERR_INVALID:
4330  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is invalid\n");
4331  break;
4332  case MB_ERR_LOCKED:
4333  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is locked\n");
4334  break;
4335  case MB_ERR_MEMALLOC:
4336  fprintf(stderr, "\t reason: out of memory\n");
4337  break;
4338  case MB_ERR_INTERNAL:
4339  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4340  break;
4341  default:
4342  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4343  break;
4344  }
4345 
4346 
4347  exit(rc);
4348  }
4349  #endif
4350  }
4351 
4352  /* Start sync message boards that don't write */
4353  if(FLAME_mortgage_payment_message_board_write == 0)
4354  {
4355  /*printf("%d> mortgage_payment message board sync start early as no agents sending any messages of this type\n", node_number);*/
4356 
4357  /* ********** sync message board here ********** */
4358  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_payment)\n");
4359  rc = MB_SyncStart(b_mortgage_payment);
4360  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_payment)\n");
4361  #ifdef ERRCHECK
4362  if (rc != MB_SUCCESS)
4363  {
4364  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_payment' board\n");
4365  switch(rc) {
4366  case MB_ERR_INVALID:
4367  fprintf(stderr, "\t reason: 'mortgage_payment' board is invalid\n");
4368  break;
4369  case MB_ERR_LOCKED:
4370  fprintf(stderr, "\t reason: 'mortgage_payment' board is locked\n");
4371  break;
4372  case MB_ERR_MEMALLOC:
4373  fprintf(stderr, "\t reason: out of memory\n");
4374  break;
4375  case MB_ERR_INTERNAL:
4376  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4377  break;
4378  default:
4379  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4380  break;
4381  }
4382 
4383 
4384  exit(rc);
4385  }
4386  #endif
4387  }
4388 
4389  /* Start sync message boards that don't write */
4390  if(FLAME_mortgage_writeoff_message_board_write == 0)
4391  {
4392  /*printf("%d> mortgage_writeoff message board sync start early as no agents sending any messages of this type\n", node_number);*/
4393 
4394  /* ********** sync message board here ********** */
4395  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_writeoff)\n");
4396  rc = MB_SyncStart(b_mortgage_writeoff);
4397  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_writeoff)\n");
4398  #ifdef ERRCHECK
4399  if (rc != MB_SUCCESS)
4400  {
4401  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_writeoff' board\n");
4402  switch(rc) {
4403  case MB_ERR_INVALID:
4404  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is invalid\n");
4405  break;
4406  case MB_ERR_LOCKED:
4407  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is locked\n");
4408  break;
4409  case MB_ERR_MEMALLOC:
4410  fprintf(stderr, "\t reason: out of memory\n");
4411  break;
4412  case MB_ERR_INTERNAL:
4413  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4414  break;
4415  default:
4416  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4417  break;
4418  }
4419 
4420 
4421  exit(rc);
4422  }
4423  #endif
4424  }
4425 
4426  /* Start sync message boards that don't write */
4427  if(FLAME_housing_transactions_summary_message_board_write == 0)
4428  {
4429  /*printf("%d> housing_transactions_summary message board sync start early as no agents sending any messages of this type\n", node_number);*/
4430 
4431  /* ********** sync message board here ********** */
4432  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_housing_transactions_summary)\n");
4433  rc = MB_SyncStart(b_housing_transactions_summary);
4434  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_housing_transactions_summary)\n");
4435  #ifdef ERRCHECK
4436  if (rc != MB_SUCCESS)
4437  {
4438  fprintf(stderr, "ERROR: Could not start sync of 'housing_transactions_summary' board\n");
4439  switch(rc) {
4440  case MB_ERR_INVALID:
4441  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is invalid\n");
4442  break;
4443  case MB_ERR_LOCKED:
4444  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is locked\n");
4445  break;
4446  case MB_ERR_MEMALLOC:
4447  fprintf(stderr, "\t reason: out of memory\n");
4448  break;
4449  case MB_ERR_INTERNAL:
4450  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
4451  break;
4452  default:
4453  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
4454  break;
4455  }
4456 
4457 
4458  exit(rc);
4459  }
4460  #endif
4461  }
4462 
4463 
4464 
4465  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start reagency_init\n");
4466  current_xmachine_reagency_holder = reagency_start_state->agents;
4467  while(current_xmachine_reagency_holder)
4468  {
4469  temp_xmachine_reagency_holder = current_xmachine_reagency_holder->next;
4470  current_xmachine_reagency = current_xmachine_reagency_holder->agent;
4471  current_xmachine_reagency_next_state = reagency_REAgencyHousingMarket_state;
4472  /* For backwards compatibility set current_xmachine */
4473  current_xmachine->xmachine_firm = NULL;
4474  current_xmachine->xmachine_household = NULL;
4475  current_xmachine->xmachine_equityfund = NULL;
4476  current_xmachine->xmachine_bank = NULL;
4477  current_xmachine->xmachine_government = NULL;
4478  current_xmachine->xmachine_centralbank = NULL;
4479  current_xmachine->xmachine_jpoffice = NULL;
4480  current_xmachine->xmachine_mall = NULL;
4481  current_xmachine->xmachine_reagency = NULL;
4482  current_xmachine->xmachine_reagency = current_xmachine_reagency;
4483 
4484 
4485 
4486 
4487 
4488  i = reagency_init();
4489 
4490 
4491 
4492  if(i == 1)
4493  {
4494  free_reagency_agent(current_xmachine_reagency_holder, reagency_start_state);
4495  }
4496  else
4497  {
4498  transition_reagency_agent(current_xmachine_reagency_holder, reagency_start_state, reagency_REAgencyHousingMarket_state);
4499  }
4500 
4501 
4502  current_xmachine_reagency = NULL;
4503 
4504  current_xmachine_reagency_holder = temp_xmachine_reagency_holder;
4505  }
4506  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish reagency_init\n");
4507 
4508 
4509  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start mall_init\n");
4510  current_xmachine_mall_holder = mall_start_state->agents;
4511  while(current_xmachine_mall_holder)
4512  {
4513  temp_xmachine_mall_holder = current_xmachine_mall_holder->next;
4514  current_xmachine_mall = current_xmachine_mall_holder->agent;
4515  current_xmachine_mall_next_state = mall_MallConsumptionMarket_state;
4516  /* For backwards compatibility set current_xmachine */
4517  current_xmachine->xmachine_firm = NULL;
4518  current_xmachine->xmachine_household = NULL;
4519  current_xmachine->xmachine_equityfund = NULL;
4520  current_xmachine->xmachine_bank = NULL;
4521  current_xmachine->xmachine_government = NULL;
4522  current_xmachine->xmachine_centralbank = NULL;
4523  current_xmachine->xmachine_jpoffice = NULL;
4524  current_xmachine->xmachine_mall = NULL;
4525  current_xmachine->xmachine_reagency = NULL;
4526  current_xmachine->xmachine_mall = current_xmachine_mall;
4527 
4528 
4529 
4530 
4531 
4532  i = mall_init();
4533 
4534 
4535 
4536  if(i == 1)
4537  {
4538  free_mall_agent(current_xmachine_mall_holder, mall_start_state);
4539  }
4540  else
4541  {
4542  transition_mall_agent(current_xmachine_mall_holder, mall_start_state, mall_MallConsumptionMarket_state);
4543  }
4544 
4545 
4546  current_xmachine_mall = NULL;
4547 
4548  current_xmachine_mall_holder = temp_xmachine_mall_holder;
4549  }
4550  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish mall_init\n");
4551 
4552 
4553  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start jpoffice_init\n");
4554  current_xmachine_jpoffice_holder = jpoffice_start_state->agents;
4555  while(current_xmachine_jpoffice_holder)
4556  {
4557  temp_xmachine_jpoffice_holder = current_xmachine_jpoffice_holder->next;
4558  current_xmachine_jpoffice = current_xmachine_jpoffice_holder->agent;
4559  current_xmachine_jpoffice_next_state = jpoffice_JPOLabourMarket_state;
4560  /* For backwards compatibility set current_xmachine */
4561  current_xmachine->xmachine_firm = NULL;
4562  current_xmachine->xmachine_household = NULL;
4563  current_xmachine->xmachine_equityfund = NULL;
4564  current_xmachine->xmachine_bank = NULL;
4565  current_xmachine->xmachine_government = NULL;
4566  current_xmachine->xmachine_centralbank = NULL;
4567  current_xmachine->xmachine_jpoffice = NULL;
4568  current_xmachine->xmachine_mall = NULL;
4569  current_xmachine->xmachine_reagency = NULL;
4570  current_xmachine->xmachine_jpoffice = current_xmachine_jpoffice;
4571 
4572 
4573 
4574 
4575 
4576  i = jpoffice_init();
4577 
4578 
4579 
4580  if(i == 1)
4581  {
4582  free_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_start_state);
4583  }
4584  else
4585  {
4586  transition_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_start_state, jpoffice_JPOLabourMarket_state);
4587  }
4588 
4589 
4590  current_xmachine_jpoffice = NULL;
4591 
4592  current_xmachine_jpoffice_holder = temp_xmachine_jpoffice_holder;
4593  }
4594  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish jpoffice_init\n");
4595 
4596 
4597  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_init\n");
4598  current_xmachine_centralbank_holder = centralbank_start_state->agents;
4599  while(current_xmachine_centralbank_holder)
4600  {
4601  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
4602  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
4603  current_xmachine_centralbank_next_state = centralbank_CentralBankCredit_state;
4604  /* For backwards compatibility set current_xmachine */
4605  current_xmachine->xmachine_firm = NULL;
4606  current_xmachine->xmachine_household = NULL;
4607  current_xmachine->xmachine_equityfund = NULL;
4608  current_xmachine->xmachine_bank = NULL;
4609  current_xmachine->xmachine_government = NULL;
4610  current_xmachine->xmachine_centralbank = NULL;
4611  current_xmachine->xmachine_jpoffice = NULL;
4612  current_xmachine->xmachine_mall = NULL;
4613  current_xmachine->xmachine_reagency = NULL;
4614  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
4615 
4616 
4617 
4618 
4619 
4620  i = centralbank_init();
4621 
4622 
4623 
4624  if(i == 1)
4625  {
4626  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_start_state);
4627  }
4628  else
4629  {
4630  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_start_state, centralbank_CentralBankCredit_state);
4631  }
4632 
4633 
4634  current_xmachine_centralbank = NULL;
4635 
4636  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
4637  }
4638  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_init\n");
4639 
4640 
4641  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_init\n");
4642  current_xmachine_government_holder = government_start_state->agents;
4643  while(current_xmachine_government_holder)
4644  {
4645  temp_xmachine_government_holder = current_xmachine_government_holder->next;
4646  current_xmachine_government = current_xmachine_government_holder->agent;
4647  current_xmachine_government_next_state = government_GovernmentStart_state;
4648  /* For backwards compatibility set current_xmachine */
4649  current_xmachine->xmachine_firm = NULL;
4650  current_xmachine->xmachine_household = NULL;
4651  current_xmachine->xmachine_equityfund = NULL;
4652  current_xmachine->xmachine_bank = NULL;
4653  current_xmachine->xmachine_government = NULL;
4654  current_xmachine->xmachine_centralbank = NULL;
4655  current_xmachine->xmachine_jpoffice = NULL;
4656  current_xmachine->xmachine_mall = NULL;
4657  current_xmachine->xmachine_reagency = NULL;
4658  current_xmachine->xmachine_government = current_xmachine_government;
4659 
4660 
4661 
4662 
4663 
4664  i = government_init();
4665 
4666 
4667 
4668  if(i == 1)
4669  {
4670  free_government_agent(current_xmachine_government_holder, government_start_state);
4671  }
4672  else
4673  {
4674  transition_government_agent(current_xmachine_government_holder, government_start_state, government_GovernmentStart_state);
4675  }
4676 
4677 
4678  current_xmachine_government = NULL;
4679 
4680  current_xmachine_government_holder = temp_xmachine_government_holder;
4681  }
4682  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_init\n");
4683 
4684 
4685  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_init\n");
4686  current_xmachine_bank_holder = bank_start_state->agents;
4687  while(current_xmachine_bank_holder)
4688  {
4689  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
4690  current_xmachine_bank = current_xmachine_bank_holder->agent;
4691  current_xmachine_bank_next_state = bank_BankCreditStart_state;
4692  /* For backwards compatibility set current_xmachine */
4693  current_xmachine->xmachine_firm = NULL;
4694  current_xmachine->xmachine_household = NULL;
4695  current_xmachine->xmachine_equityfund = NULL;
4696  current_xmachine->xmachine_bank = NULL;
4697  current_xmachine->xmachine_government = NULL;
4698  current_xmachine->xmachine_centralbank = NULL;
4699  current_xmachine->xmachine_jpoffice = NULL;
4700  current_xmachine->xmachine_mall = NULL;
4701  current_xmachine->xmachine_reagency = NULL;
4702  current_xmachine->xmachine_bank = current_xmachine_bank;
4703 
4704 
4705 
4706 
4707 
4708  i = bank_init();
4709 
4710 
4711 
4712  if(i == 1)
4713  {
4714  free_bank_agent(current_xmachine_bank_holder, bank_start_state);
4715  }
4716  else
4717  {
4718  transition_bank_agent(current_xmachine_bank_holder, bank_start_state, bank_BankCreditStart_state);
4719  }
4720 
4721 
4722  current_xmachine_bank = NULL;
4723 
4724  current_xmachine_bank_holder = temp_xmachine_bank_holder;
4725  }
4726  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_init\n");
4727 
4728 
4729  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_init\n");
4730  current_xmachine_equityfund_holder = equityfund_start_state->agents;
4731  while(current_xmachine_equityfund_holder)
4732  {
4733  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
4734  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
4735  current_xmachine_equityfund_next_state = equityfund_EquityFundStart_state;
4736  /* For backwards compatibility set current_xmachine */
4737  current_xmachine->xmachine_firm = NULL;
4738  current_xmachine->xmachine_household = NULL;
4739  current_xmachine->xmachine_equityfund = NULL;
4740  current_xmachine->xmachine_bank = NULL;
4741  current_xmachine->xmachine_government = NULL;
4742  current_xmachine->xmachine_centralbank = NULL;
4743  current_xmachine->xmachine_jpoffice = NULL;
4744  current_xmachine->xmachine_mall = NULL;
4745  current_xmachine->xmachine_reagency = NULL;
4746  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
4747 
4748 
4749 
4750 
4751 
4752  i = equityfund_init();
4753 
4754 
4755 
4756  if(i == 1)
4757  {
4758  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_start_state);
4759  }
4760  else
4761  {
4762  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_start_state, equityfund_EquityFundStart_state);
4763  }
4764 
4765 
4766  current_xmachine_equityfund = NULL;
4767 
4768  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
4769  }
4770  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_init\n");
4771 
4772 
4773  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_init\n");
4774  current_xmachine_household_holder = household_start_state->agents;
4775  while(current_xmachine_household_holder)
4776  {
4777  temp_xmachine_household_holder = current_xmachine_household_holder->next;
4778  current_xmachine_household = current_xmachine_household_holder->agent;
4779  current_xmachine_household_next_state = household_HHCreditStart_state;
4780  /* For backwards compatibility set current_xmachine */
4781  current_xmachine->xmachine_firm = NULL;
4782  current_xmachine->xmachine_household = NULL;
4783  current_xmachine->xmachine_equityfund = NULL;
4784  current_xmachine->xmachine_bank = NULL;
4785  current_xmachine->xmachine_government = NULL;
4786  current_xmachine->xmachine_centralbank = NULL;
4787  current_xmachine->xmachine_jpoffice = NULL;
4788  current_xmachine->xmachine_mall = NULL;
4789  current_xmachine->xmachine_reagency = NULL;
4790  current_xmachine->xmachine_household = current_xmachine_household;
4791 
4792 
4793 
4794 
4795 
4796  i = household_init();
4797 
4798 
4799 
4800  if(i == 1)
4801  {
4802  free_household_agent(current_xmachine_household_holder, household_start_state);
4803  }
4804  else
4805  {
4806  transition_household_agent(current_xmachine_household_holder, household_start_state, household_HHCreditStart_state);
4807  }
4808 
4809 
4810  current_xmachine_household = NULL;
4811 
4812  current_xmachine_household_holder = temp_xmachine_household_holder;
4813  }
4814  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_init\n");
4815 
4816 
4817  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_init\n");
4818  current_xmachine_firm_holder = firm_start_state->agents;
4819  while(current_xmachine_firm_holder)
4820  {
4821  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
4822  current_xmachine_firm = current_xmachine_firm_holder->agent;
4823  current_xmachine_firm_next_state = firm_FirmCreditStart_state;
4824  /* For backwards compatibility set current_xmachine */
4825  current_xmachine->xmachine_firm = NULL;
4826  current_xmachine->xmachine_household = NULL;
4827  current_xmachine->xmachine_equityfund = NULL;
4828  current_xmachine->xmachine_bank = NULL;
4829  current_xmachine->xmachine_government = NULL;
4830  current_xmachine->xmachine_centralbank = NULL;
4831  current_xmachine->xmachine_jpoffice = NULL;
4832  current_xmachine->xmachine_mall = NULL;
4833  current_xmachine->xmachine_reagency = NULL;
4834  current_xmachine->xmachine_firm = current_xmachine_firm;
4835 
4836 
4837 
4838 
4839 
4840  i = firm_init();
4841 
4842 
4843 
4844  if(i == 1)
4845  {
4846  free_firm_agent(current_xmachine_firm_holder, firm_start_state);
4847  }
4848  else
4849  {
4850  transition_firm_agent(current_xmachine_firm_holder, firm_start_state, firm_FirmCreditStart_state);
4851  }
4852 
4853 
4854  current_xmachine_firm = NULL;
4855 
4856  current_xmachine_firm_holder = temp_xmachine_firm_holder;
4857  }
4858  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_init\n");
4859 
4860 
4861 /* End of layer number 0 */
4862 
4863 /* Clear message boards that have finished being used
4864  * and sync complete if doing late sync complete */
4865 
4866  /* DEBUG: States with branching functions */
4867  current_xmachine_firm_holder = firm_FirmCreditStart_state->agents;
4868  while(current_xmachine_firm_holder)
4869  {
4870  FLAME_debug_count = 0;
4871  /* Function: firm_credit_compute_income_statement */
4872  if(FLAME_condition_firm_firm_credit_compute_income_statement_FirmCreditStart_FirmCreditInvestment(current_xmachine_firm_holder->agent)==1)
4873  { FLAME_debug_count++; }
4874  /* Function: idle */
4875  if(FLAME_condition_firm_idle_FirmCreditStart_FirmProductionStart(current_xmachine_firm_holder->agent)==1)
4876  { FLAME_debug_count++; }
4877  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
4878  if(FLAME_debug_count != 1)
4879  {
4880  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmCreditStart'\n");
4881  if(FLAME_debug_count > 1)
4882  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
4883  if(FLAME_debug_count == 0)
4884  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
4885  }
4886 
4887  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
4888  }
4889  /* DEBUG: States with branching functions */
4890  current_xmachine_household_holder = household_HHCreditStart_state->agents;
4891  while(current_xmachine_household_holder)
4892  {
4893  FLAME_debug_count = 0;
4894  /* Function: household_credit_update_mortgage_rates */
4895  if(FLAME_condition_household_household_credit_update_mortgage_rates_HHCreditStart_HHCreditIsCapitalist(current_xmachine_household_holder->agent)==1)
4896  { FLAME_debug_count++; }
4897  /* Function: idle */
4898  if(FLAME_condition_household_idle_HHCreditStart_HHCreditMonthly(current_xmachine_household_holder->agent)==1)
4899  { FLAME_debug_count++; }
4900  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
4901  if(FLAME_debug_count != 1)
4902  {
4903  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHCreditStart'\n");
4904  if(FLAME_debug_count > 1)
4905  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
4906  if(FLAME_debug_count == 0)
4907  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
4908  }
4909 
4910  current_xmachine_household_holder = current_xmachine_household_holder->next;
4911  }
4912  /* DEBUG: States with branching functions */
4913  current_xmachine_equityfund_holder = equityfund_EquityFundStart_state->agents;
4914  while(current_xmachine_equityfund_holder)
4915  {
4916  FLAME_debug_count = 0;
4917  /* Function: equityfund_credit_invest_illiquids */
4918  if(FLAME_condition_equityfund_equityfund_credit_invest_illiquids_EquityFundStart_EFCreditDistributeShares(current_xmachine_equityfund_holder->agent)==1)
4919  { FLAME_debug_count++; }
4920  /* Function: idle */
4921  if(FLAME_condition_equityfund_idle_EquityFundStart_EFLabourMarket(current_xmachine_equityfund_holder->agent)==1)
4922  { FLAME_debug_count++; }
4923  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
4924  if(FLAME_debug_count != 1)
4925  {
4926  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'equityfund' leaving state 'EquityFundStart'\n");
4927  if(FLAME_debug_count > 1)
4928  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
4929  if(FLAME_debug_count == 0)
4930  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
4931  }
4932 
4933  current_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
4934  }
4935  /* DEBUG: States with branching functions */
4936  current_xmachine_bank_holder = bank_BankCreditStart_state->agents;
4937  while(current_xmachine_bank_holder)
4938  {
4939  FLAME_debug_count = 0;
4940  /* Function: bank_credit_compute_income_statement */
4941  if(FLAME_condition_bank_bank_credit_compute_income_statement_BankCreditStart_BankCreditDividends(current_xmachine_bank_holder->agent)==1)
4942  { FLAME_debug_count++; }
4943  /* Function: idle */
4944  if(FLAME_condition_bank_idle_BankCreditStart_BankHousingMarket(current_xmachine_bank_holder->agent)==1)
4945  { FLAME_debug_count++; }
4946  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
4947  if(FLAME_debug_count != 1)
4948  {
4949  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'bank' leaving state 'BankCreditStart'\n");
4950  if(FLAME_debug_count > 1)
4951  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
4952  if(FLAME_debug_count == 0)
4953  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
4954  }
4955 
4956  current_xmachine_bank_holder = current_xmachine_bank_holder->next;
4957  }
4958  /* DEBUG: States with branching functions */
4959  current_xmachine_government_holder = government_GovernmentStart_state->agents;
4960  while(current_xmachine_government_holder)
4961  {
4962  FLAME_debug_count = 0;
4963  /* Function: government_collect_capital_tax */
4964  if(FLAME_condition_government_government_collect_capital_tax_GovernmentStart_GovernmentCentralbankProfits(current_xmachine_government_holder->agent)==1)
4965  { FLAME_debug_count++; }
4966  /* Function: idle */
4967  if(FLAME_condition_government_idle_GovernmentStart_GovernmentMonthly(current_xmachine_government_holder->agent)==1)
4968  { FLAME_debug_count++; }
4969  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
4970  if(FLAME_debug_count != 1)
4971  {
4972  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'government' leaving state 'GovernmentStart'\n");
4973  if(FLAME_debug_count > 1)
4974  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
4975  if(FLAME_debug_count == 0)
4976  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
4977  }
4978 
4979  current_xmachine_government_holder = current_xmachine_government_holder->next;
4980  }
4981  /* DEBUG: States with branching functions */
4982  current_xmachine_centralbank_holder = centralbank_CentralBankCredit_state->agents;
4983  while(current_xmachine_centralbank_holder)
4984  {
4985  FLAME_debug_count = 0;
4986  /* Function: centralbank_collect_interest_payments */
4987  if(FLAME_condition_centralbank_centralbank_collect_interest_payments_CentralBankCredit_CentralBankDebtRequests(current_xmachine_centralbank_holder->agent)==1)
4988  { FLAME_debug_count++; }
4989  /* Function: idle */
4990  if(FLAME_condition_centralbank_idle_CentralBankCredit_CentralBankLabour(current_xmachine_centralbank_holder->agent)==1)
4991  { FLAME_debug_count++; }
4992  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
4993  if(FLAME_debug_count != 1)
4994  {
4995  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'centralbank' leaving state 'CentralBankCredit'\n");
4996  if(FLAME_debug_count > 1)
4997  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
4998  if(FLAME_debug_count == 0)
4999  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
5000  }
5001 
5002  current_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
5003  }
5004  /* DEBUG: States with branching functions */
5005  current_xmachine_jpoffice_holder = jpoffice_JPOLabourMarket_state->agents;
5006  while(current_xmachine_jpoffice_holder)
5007  {
5008  FLAME_debug_count = 0;
5009  /* Function: jpoffice_labour_stage1 */
5010  if(FLAME_condition_jpoffice_jpoffice_labour_stage1_JPOLabourMarket_JPOLabourStage2(current_xmachine_jpoffice_holder->agent)==1)
5011  { FLAME_debug_count++; }
5012  /* Function: idle */
5013  if(FLAME_condition_jpoffice_idle_JPOLabourMarket_end(current_xmachine_jpoffice_holder->agent)==1)
5014  { FLAME_debug_count++; }
5015  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
5016  if(FLAME_debug_count != 1)
5017  {
5018  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'jpoffice' leaving state 'JPOLabourMarket'\n");
5019  if(FLAME_debug_count > 1)
5020  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
5021  if(FLAME_debug_count == 0)
5022  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
5023  }
5024 
5025  current_xmachine_jpoffice_holder = current_xmachine_jpoffice_holder->next;
5026  }
5027  /* DEBUG: States with branching functions */
5028  current_xmachine_mall_holder = mall_MallConsumptionMarket_state->agents;
5029  while(current_xmachine_mall_holder)
5030  {
5031  FLAME_debug_count = 0;
5032  /* Function: mall_consumption_shopping */
5033  if(FLAME_condition_mall_mall_consumption_shopping_MallConsumptionMarket_MallConsumptionSummary(current_xmachine_mall_holder->agent)==1)
5034  { FLAME_debug_count++; }
5035  /* Function: idle */
5036  if(FLAME_condition_mall_idle_MallConsumptionMarket_end(current_xmachine_mall_holder->agent)==1)
5037  { FLAME_debug_count++; }
5038  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
5039  if(FLAME_debug_count != 1)
5040  {
5041  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'mall' leaving state 'MallConsumptionMarket'\n");
5042  if(FLAME_debug_count > 1)
5043  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
5044  if(FLAME_debug_count == 0)
5045  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
5046  }
5047 
5048  current_xmachine_mall_holder = current_xmachine_mall_holder->next;
5049  }
5050  /* DEBUG: States with branching functions */
5051  current_xmachine_reagency_holder = reagency_REAgencyHousingMarket_state->agents;
5052  while(current_xmachine_reagency_holder)
5053  {
5054  FLAME_debug_count = 0;
5055  /* Function: reagency_housing_check_interest_rate */
5056  if(FLAME_condition_reagency_reagency_housing_check_interest_rate_REAgencyHousingMarket_REAgencyHousingProcess(current_xmachine_reagency_holder->agent)==1)
5057  { FLAME_debug_count++; }
5058  /* Function: idle */
5059  if(FLAME_condition_reagency_idle_REAgencyHousingMarket_end(current_xmachine_reagency_holder->agent)==1)
5060  { FLAME_debug_count++; }
5061  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
5062  if(FLAME_debug_count != 1)
5063  {
5064  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'reagency' leaving state 'REAgencyHousingMarket'\n");
5065  if(FLAME_debug_count > 1)
5066  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
5067  if(FLAME_debug_count == 0)
5068  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
5069  }
5070 
5071  current_xmachine_reagency_holder = current_xmachine_reagency_holder->next;
5072  }
5073 
5074  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_compute_income_statement\n");
5075  current_xmachine_bank_holder = bank_BankCreditStart_state->agents;
5076  while(current_xmachine_bank_holder)
5077  {
5078  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
5079  current_xmachine_bank = current_xmachine_bank_holder->agent;
5080  current_xmachine_bank_next_state = bank_BankCreditDividends_state;
5081  /* For backwards compatibility set current_xmachine */
5082  current_xmachine->xmachine_firm = NULL;
5083  current_xmachine->xmachine_household = NULL;
5084  current_xmachine->xmachine_equityfund = NULL;
5085  current_xmachine->xmachine_bank = NULL;
5086  current_xmachine->xmachine_government = NULL;
5087  current_xmachine->xmachine_centralbank = NULL;
5088  current_xmachine->xmachine_jpoffice = NULL;
5089  current_xmachine->xmachine_mall = NULL;
5090  current_xmachine->xmachine_reagency = NULL;
5091  current_xmachine->xmachine_bank = current_xmachine_bank;
5092 
5093  if(FLAME_condition_bank_bank_credit_compute_income_statement_BankCreditStart_BankCreditDividends(current_xmachine_bank)==1)
5094  {
5095 
5096 
5097 
5098  i = bank_credit_compute_income_statement();
5099 
5100 
5101 
5102  if(i == 1)
5103  {
5104  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditStart_state);
5105  }
5106  else
5107  {
5108  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditStart_state, bank_BankCreditDividends_state);
5109  }
5110  }
5111 
5112  current_xmachine_bank = NULL;
5113 
5114  current_xmachine_bank_holder = temp_xmachine_bank_holder;
5115  }
5116  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_compute_income_statement\n");
5117 
5118  if(FLAME_bank_centralbank_interest_payment_message_board_write == 1)
5119  {
5120 
5121  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bank_centralbank_interest_payment)\n");
5122  rc = MB_SyncStart(b_bank_centralbank_interest_payment);
5123  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bank_centralbank_interest_payment)\n");
5124  #ifdef ERRCHECK
5125  if (rc != MB_SUCCESS)
5126  {
5127  fprintf(stderr, "ERROR: Could not start sync of 'bank_centralbank_interest_payment' board\n");
5128  switch(rc) {
5129  case MB_ERR_INVALID:
5130  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is invalid\n");
5131  break;
5132  case MB_ERR_LOCKED:
5133  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is locked\n");
5134  break;
5135  case MB_ERR_MEMALLOC:
5136  fprintf(stderr, "\t reason: out of memory\n");
5137  break;
5138  case MB_ERR_INTERNAL:
5139  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
5140  break;
5141  default:
5142  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
5143  break;
5144  }
5145 
5146 
5147  exit(rc);
5148  }
5149  #endif
5150  }
5151 
5152 
5153 
5154  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5155  current_xmachine_reagency_holder = reagency_REAgencyHousingMarket_state->agents;
5156  while(current_xmachine_reagency_holder)
5157  {
5158  temp_xmachine_reagency_holder = current_xmachine_reagency_holder->next;
5159  current_xmachine_reagency = current_xmachine_reagency_holder->agent;
5160  current_xmachine_reagency_next_state = reagency_end_state;
5161  /* For backwards compatibility set current_xmachine */
5162  current_xmachine->xmachine_firm = NULL;
5163  current_xmachine->xmachine_household = NULL;
5164  current_xmachine->xmachine_equityfund = NULL;
5165  current_xmachine->xmachine_bank = NULL;
5166  current_xmachine->xmachine_government = NULL;
5167  current_xmachine->xmachine_centralbank = NULL;
5168  current_xmachine->xmachine_jpoffice = NULL;
5169  current_xmachine->xmachine_mall = NULL;
5170  current_xmachine->xmachine_reagency = NULL;
5171  current_xmachine->xmachine_reagency = current_xmachine_reagency;
5172 
5173  if(FLAME_condition_reagency_idle_REAgencyHousingMarket_end(current_xmachine_reagency)==1)
5174  {
5175 
5176 
5177 
5178  i = idle();
5179 
5180 
5181 
5182  if(i == 1)
5183  {
5184  free_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingMarket_state);
5185  }
5186  else
5187  {
5188  transition_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingMarket_state, reagency_end_state);
5189  }
5190  }
5191 
5192  current_xmachine_reagency = NULL;
5193 
5194  current_xmachine_reagency_holder = temp_xmachine_reagency_holder;
5195  }
5196  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5197 
5198 
5199  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5200  current_xmachine_mall_holder = mall_MallConsumptionMarket_state->agents;
5201  while(current_xmachine_mall_holder)
5202  {
5203  temp_xmachine_mall_holder = current_xmachine_mall_holder->next;
5204  current_xmachine_mall = current_xmachine_mall_holder->agent;
5205  current_xmachine_mall_next_state = mall_end_state;
5206  /* For backwards compatibility set current_xmachine */
5207  current_xmachine->xmachine_firm = NULL;
5208  current_xmachine->xmachine_household = NULL;
5209  current_xmachine->xmachine_equityfund = NULL;
5210  current_xmachine->xmachine_bank = NULL;
5211  current_xmachine->xmachine_government = NULL;
5212  current_xmachine->xmachine_centralbank = NULL;
5213  current_xmachine->xmachine_jpoffice = NULL;
5214  current_xmachine->xmachine_mall = NULL;
5215  current_xmachine->xmachine_reagency = NULL;
5216  current_xmachine->xmachine_mall = current_xmachine_mall;
5217 
5218  if(FLAME_condition_mall_idle_MallConsumptionMarket_end(current_xmachine_mall)==1)
5219  {
5220 
5221 
5222 
5223  i = idle();
5224 
5225 
5226 
5227  if(i == 1)
5228  {
5229  free_mall_agent(current_xmachine_mall_holder, mall_MallConsumptionMarket_state);
5230  }
5231  else
5232  {
5233  transition_mall_agent(current_xmachine_mall_holder, mall_MallConsumptionMarket_state, mall_end_state);
5234  }
5235  }
5236 
5237  current_xmachine_mall = NULL;
5238 
5239  current_xmachine_mall_holder = temp_xmachine_mall_holder;
5240  }
5241  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5242 
5243 
5244  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5245  current_xmachine_jpoffice_holder = jpoffice_JPOLabourMarket_state->agents;
5246  while(current_xmachine_jpoffice_holder)
5247  {
5248  temp_xmachine_jpoffice_holder = current_xmachine_jpoffice_holder->next;
5249  current_xmachine_jpoffice = current_xmachine_jpoffice_holder->agent;
5250  current_xmachine_jpoffice_next_state = jpoffice_end_state;
5251  /* For backwards compatibility set current_xmachine */
5252  current_xmachine->xmachine_firm = NULL;
5253  current_xmachine->xmachine_household = NULL;
5254  current_xmachine->xmachine_equityfund = NULL;
5255  current_xmachine->xmachine_bank = NULL;
5256  current_xmachine->xmachine_government = NULL;
5257  current_xmachine->xmachine_centralbank = NULL;
5258  current_xmachine->xmachine_jpoffice = NULL;
5259  current_xmachine->xmachine_mall = NULL;
5260  current_xmachine->xmachine_reagency = NULL;
5261  current_xmachine->xmachine_jpoffice = current_xmachine_jpoffice;
5262 
5263  if(FLAME_condition_jpoffice_idle_JPOLabourMarket_end(current_xmachine_jpoffice)==1)
5264  {
5265 
5266 
5267 
5268  i = idle();
5269 
5270 
5271 
5272  if(i == 1)
5273  {
5274  free_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_JPOLabourMarket_state);
5275  }
5276  else
5277  {
5278  transition_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_JPOLabourMarket_state, jpoffice_end_state);
5279  }
5280  }
5281 
5282  current_xmachine_jpoffice = NULL;
5283 
5284  current_xmachine_jpoffice_holder = temp_xmachine_jpoffice_holder;
5285  }
5286  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5287 
5288 
5289  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5290  current_xmachine_centralbank_holder = centralbank_CentralBankCredit_state->agents;
5291  while(current_xmachine_centralbank_holder)
5292  {
5293  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
5294  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
5295  current_xmachine_centralbank_next_state = centralbank_CentralBankLabour_state;
5296  /* For backwards compatibility set current_xmachine */
5297  current_xmachine->xmachine_firm = NULL;
5298  current_xmachine->xmachine_household = NULL;
5299  current_xmachine->xmachine_equityfund = NULL;
5300  current_xmachine->xmachine_bank = NULL;
5301  current_xmachine->xmachine_government = NULL;
5302  current_xmachine->xmachine_centralbank = NULL;
5303  current_xmachine->xmachine_jpoffice = NULL;
5304  current_xmachine->xmachine_mall = NULL;
5305  current_xmachine->xmachine_reagency = NULL;
5306  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
5307 
5308  if(FLAME_condition_centralbank_idle_CentralBankCredit_CentralBankLabour(current_xmachine_centralbank)==1)
5309  {
5310 
5311 
5312 
5313  i = idle();
5314 
5315 
5316 
5317  if(i == 1)
5318  {
5319  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankCredit_state);
5320  }
5321  else
5322  {
5323  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankCredit_state, centralbank_CentralBankLabour_state);
5324  }
5325  }
5326 
5327  current_xmachine_centralbank = NULL;
5328 
5329  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
5330  }
5331  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5332 
5333 
5334  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5335  current_xmachine_government_holder = government_GovernmentStart_state->agents;
5336  while(current_xmachine_government_holder)
5337  {
5338  temp_xmachine_government_holder = current_xmachine_government_holder->next;
5339  current_xmachine_government = current_xmachine_government_holder->agent;
5340  current_xmachine_government_next_state = government_GovernmentMonthly_state;
5341  /* For backwards compatibility set current_xmachine */
5342  current_xmachine->xmachine_firm = NULL;
5343  current_xmachine->xmachine_household = NULL;
5344  current_xmachine->xmachine_equityfund = NULL;
5345  current_xmachine->xmachine_bank = NULL;
5346  current_xmachine->xmachine_government = NULL;
5347  current_xmachine->xmachine_centralbank = NULL;
5348  current_xmachine->xmachine_jpoffice = NULL;
5349  current_xmachine->xmachine_mall = NULL;
5350  current_xmachine->xmachine_reagency = NULL;
5351  current_xmachine->xmachine_government = current_xmachine_government;
5352 
5353  if(FLAME_condition_government_idle_GovernmentStart_GovernmentMonthly(current_xmachine_government)==1)
5354  {
5355 
5356 
5357 
5358  i = idle();
5359 
5360 
5361 
5362  if(i == 1)
5363  {
5364  free_government_agent(current_xmachine_government_holder, government_GovernmentStart_state);
5365  }
5366  else
5367  {
5368  transition_government_agent(current_xmachine_government_holder, government_GovernmentStart_state, government_GovernmentMonthly_state);
5369  }
5370  }
5371 
5372  current_xmachine_government = NULL;
5373 
5374  current_xmachine_government_holder = temp_xmachine_government_holder;
5375  }
5376  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5377 
5378 
5379  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5380  current_xmachine_bank_holder = bank_BankCreditStart_state->agents;
5381  while(current_xmachine_bank_holder)
5382  {
5383  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
5384  current_xmachine_bank = current_xmachine_bank_holder->agent;
5385  current_xmachine_bank_next_state = bank_BankHousingMarket_state;
5386  /* For backwards compatibility set current_xmachine */
5387  current_xmachine->xmachine_firm = NULL;
5388  current_xmachine->xmachine_household = NULL;
5389  current_xmachine->xmachine_equityfund = NULL;
5390  current_xmachine->xmachine_bank = NULL;
5391  current_xmachine->xmachine_government = NULL;
5392  current_xmachine->xmachine_centralbank = NULL;
5393  current_xmachine->xmachine_jpoffice = NULL;
5394  current_xmachine->xmachine_mall = NULL;
5395  current_xmachine->xmachine_reagency = NULL;
5396  current_xmachine->xmachine_bank = current_xmachine_bank;
5397 
5398  if(FLAME_condition_bank_idle_BankCreditStart_BankHousingMarket(current_xmachine_bank)==1)
5399  {
5400 
5401 
5402 
5403  i = idle();
5404 
5405 
5406 
5407  if(i == 1)
5408  {
5409  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditStart_state);
5410  }
5411  else
5412  {
5413  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditStart_state, bank_BankHousingMarket_state);
5414  }
5415  }
5416 
5417  current_xmachine_bank = NULL;
5418 
5419  current_xmachine_bank_holder = temp_xmachine_bank_holder;
5420  }
5421  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5422 
5423 
5424  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5425  current_xmachine_equityfund_holder = equityfund_EquityFundStart_state->agents;
5426  while(current_xmachine_equityfund_holder)
5427  {
5428  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
5429  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
5430  current_xmachine_equityfund_next_state = equityfund_EFLabourMarket_state;
5431  /* For backwards compatibility set current_xmachine */
5432  current_xmachine->xmachine_firm = NULL;
5433  current_xmachine->xmachine_household = NULL;
5434  current_xmachine->xmachine_equityfund = NULL;
5435  current_xmachine->xmachine_bank = NULL;
5436  current_xmachine->xmachine_government = NULL;
5437  current_xmachine->xmachine_centralbank = NULL;
5438  current_xmachine->xmachine_jpoffice = NULL;
5439  current_xmachine->xmachine_mall = NULL;
5440  current_xmachine->xmachine_reagency = NULL;
5441  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
5442 
5443  if(FLAME_condition_equityfund_idle_EquityFundStart_EFLabourMarket(current_xmachine_equityfund)==1)
5444  {
5445 
5446 
5447 
5448  i = idle();
5449 
5450 
5451 
5452  if(i == 1)
5453  {
5454  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EquityFundStart_state);
5455  }
5456  else
5457  {
5458  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EquityFundStart_state, equityfund_EFLabourMarket_state);
5459  }
5460  }
5461 
5462  current_xmachine_equityfund = NULL;
5463 
5464  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
5465  }
5466  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5467 
5468 
5469  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_credit_update_mortgage_rates\n");
5470  current_xmachine_household_holder = household_HHCreditStart_state->agents;
5471  while(current_xmachine_household_holder)
5472  {
5473  temp_xmachine_household_holder = current_xmachine_household_holder->next;
5474  current_xmachine_household = current_xmachine_household_holder->agent;
5475  current_xmachine_household_next_state = household_HHCreditIsCapitalist_state;
5476  /* For backwards compatibility set current_xmachine */
5477  current_xmachine->xmachine_firm = NULL;
5478  current_xmachine->xmachine_household = NULL;
5479  current_xmachine->xmachine_equityfund = NULL;
5480  current_xmachine->xmachine_bank = NULL;
5481  current_xmachine->xmachine_government = NULL;
5482  current_xmachine->xmachine_centralbank = NULL;
5483  current_xmachine->xmachine_jpoffice = NULL;
5484  current_xmachine->xmachine_mall = NULL;
5485  current_xmachine->xmachine_reagency = NULL;
5486  current_xmachine->xmachine_household = current_xmachine_household;
5487 
5488  if(FLAME_condition_household_household_credit_update_mortgage_rates_HHCreditStart_HHCreditIsCapitalist(current_xmachine_household)==1)
5489  {
5490 
5491 
5492 
5493  i = household_credit_update_mortgage_rates();
5494 
5495 
5496 
5497  if(i == 1)
5498  {
5499  free_household_agent(current_xmachine_household_holder, household_HHCreditStart_state);
5500  }
5501  else
5502  {
5503  transition_household_agent(current_xmachine_household_holder, household_HHCreditStart_state, household_HHCreditIsCapitalist_state);
5504  }
5505  }
5506 
5507  current_xmachine_household = NULL;
5508 
5509  current_xmachine_household_holder = temp_xmachine_household_holder;
5510  }
5511  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_credit_update_mortgage_rates\n");
5512 
5513 
5514  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5515  current_xmachine_household_holder = household_HHCreditStart_state->agents;
5516  while(current_xmachine_household_holder)
5517  {
5518  temp_xmachine_household_holder = current_xmachine_household_holder->next;
5519  current_xmachine_household = current_xmachine_household_holder->agent;
5520  current_xmachine_household_next_state = household_HHCreditMonthly_state;
5521  /* For backwards compatibility set current_xmachine */
5522  current_xmachine->xmachine_firm = NULL;
5523  current_xmachine->xmachine_household = NULL;
5524  current_xmachine->xmachine_equityfund = NULL;
5525  current_xmachine->xmachine_bank = NULL;
5526  current_xmachine->xmachine_government = NULL;
5527  current_xmachine->xmachine_centralbank = NULL;
5528  current_xmachine->xmachine_jpoffice = NULL;
5529  current_xmachine->xmachine_mall = NULL;
5530  current_xmachine->xmachine_reagency = NULL;
5531  current_xmachine->xmachine_household = current_xmachine_household;
5532 
5533  if(FLAME_condition_household_idle_HHCreditStart_HHCreditMonthly(current_xmachine_household)==1)
5534  {
5535 
5536 
5537 
5538  i = idle();
5539 
5540 
5541 
5542  if(i == 1)
5543  {
5544  free_household_agent(current_xmachine_household_holder, household_HHCreditStart_state);
5545  }
5546  else
5547  {
5548  transition_household_agent(current_xmachine_household_holder, household_HHCreditStart_state, household_HHCreditMonthly_state);
5549  }
5550  }
5551 
5552  current_xmachine_household = NULL;
5553 
5554  current_xmachine_household_holder = temp_xmachine_household_holder;
5555  }
5556  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5557 
5558 
5559  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_compute_income_statement\n");
5560  current_xmachine_firm_holder = firm_FirmCreditStart_state->agents;
5561  while(current_xmachine_firm_holder)
5562  {
5563  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
5564  current_xmachine_firm = current_xmachine_firm_holder->agent;
5565  current_xmachine_firm_next_state = firm_FirmCreditInvestment_state;
5566  /* For backwards compatibility set current_xmachine */
5567  current_xmachine->xmachine_firm = NULL;
5568  current_xmachine->xmachine_household = NULL;
5569  current_xmachine->xmachine_equityfund = NULL;
5570  current_xmachine->xmachine_bank = NULL;
5571  current_xmachine->xmachine_government = NULL;
5572  current_xmachine->xmachine_centralbank = NULL;
5573  current_xmachine->xmachine_jpoffice = NULL;
5574  current_xmachine->xmachine_mall = NULL;
5575  current_xmachine->xmachine_reagency = NULL;
5576  current_xmachine->xmachine_firm = current_xmachine_firm;
5577 
5578  if(FLAME_condition_firm_firm_credit_compute_income_statement_FirmCreditStart_FirmCreditInvestment(current_xmachine_firm)==1)
5579  {
5580 
5581 
5582 
5583  i = firm_credit_compute_income_statement();
5584 
5585 
5586 
5587  if(i == 1)
5588  {
5589  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStart_state);
5590  }
5591  else
5592  {
5593  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStart_state, firm_FirmCreditInvestment_state);
5594  }
5595  }
5596 
5597  current_xmachine_firm = NULL;
5598 
5599  current_xmachine_firm_holder = temp_xmachine_firm_holder;
5600  }
5601  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_compute_income_statement\n");
5602 
5603 
5604  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5605  current_xmachine_firm_holder = firm_FirmCreditStart_state->agents;
5606  while(current_xmachine_firm_holder)
5607  {
5608  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
5609  current_xmachine_firm = current_xmachine_firm_holder->agent;
5610  current_xmachine_firm_next_state = firm_FirmProductionStart_state;
5611  /* For backwards compatibility set current_xmachine */
5612  current_xmachine->xmachine_firm = NULL;
5613  current_xmachine->xmachine_household = NULL;
5614  current_xmachine->xmachine_equityfund = NULL;
5615  current_xmachine->xmachine_bank = NULL;
5616  current_xmachine->xmachine_government = NULL;
5617  current_xmachine->xmachine_centralbank = NULL;
5618  current_xmachine->xmachine_jpoffice = NULL;
5619  current_xmachine->xmachine_mall = NULL;
5620  current_xmachine->xmachine_reagency = NULL;
5621  current_xmachine->xmachine_firm = current_xmachine_firm;
5622 
5623  if(FLAME_condition_firm_idle_FirmCreditStart_FirmProductionStart(current_xmachine_firm)==1)
5624  {
5625 
5626 
5627 
5628  i = idle();
5629 
5630 
5631 
5632  if(i == 1)
5633  {
5634  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStart_state);
5635  }
5636  else
5637  {
5638  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStart_state, firm_FirmProductionStart_state);
5639  }
5640  }
5641 
5642  current_xmachine_firm = NULL;
5643 
5644  current_xmachine_firm_holder = temp_xmachine_firm_holder;
5645  }
5646  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5647 
5648 
5649 /* End of layer number 1 */
5650 
5651 /* Clear message boards that have finished being used
5652  * and sync complete if doing late sync complete */
5653 
5654  /* DEBUG: States with branching functions */
5655  current_xmachine_household_holder = household_HHCreditIsCapitalist_state->agents;
5656  while(current_xmachine_household_holder)
5657  {
5658  FLAME_debug_count = 0;
5659  /* Function: household_credit_collect_shares */
5660  if(FLAME_condition_household_household_credit_collect_shares_HHCreditIsCapitalist_HHCreditBalanceSheet(current_xmachine_household_holder->agent)==1)
5661  { FLAME_debug_count++; }
5662  /* Function: idle */
5663  if(FLAME_condition_household_idle_HHCreditIsCapitalist_HHCreditBalanceSheet(current_xmachine_household_holder->agent)==1)
5664  { FLAME_debug_count++; }
5665  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
5666  if(FLAME_debug_count != 1)
5667  {
5668  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHCreditIsCapitalist'\n");
5669  if(FLAME_debug_count > 1)
5670  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
5671  if(FLAME_debug_count == 0)
5672  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
5673  }
5674 
5675  current_xmachine_household_holder = current_xmachine_household_holder->next;
5676  }
5677 
5678  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_compute_dividends\n");
5679  current_xmachine_bank_holder = bank_BankCreditDividends_state->agents;
5680  while(current_xmachine_bank_holder)
5681  {
5682  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
5683  current_xmachine_bank = current_xmachine_bank_holder->agent;
5684  current_xmachine_bank_next_state = bank_BankCreditBalanceSheet_state;
5685  /* For backwards compatibility set current_xmachine */
5686  current_xmachine->xmachine_firm = NULL;
5687  current_xmachine->xmachine_household = NULL;
5688  current_xmachine->xmachine_equityfund = NULL;
5689  current_xmachine->xmachine_bank = NULL;
5690  current_xmachine->xmachine_government = NULL;
5691  current_xmachine->xmachine_centralbank = NULL;
5692  current_xmachine->xmachine_jpoffice = NULL;
5693  current_xmachine->xmachine_mall = NULL;
5694  current_xmachine->xmachine_reagency = NULL;
5695  current_xmachine->xmachine_bank = current_xmachine_bank;
5696 
5697 
5698 
5699 
5700 
5701  i = bank_credit_compute_dividends();
5702 
5703 
5704 
5705  if(i == 1)
5706  {
5707  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditDividends_state);
5708  }
5709  else
5710  {
5711  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditDividends_state, bank_BankCreditBalanceSheet_state);
5712  }
5713 
5714 
5715  current_xmachine_bank = NULL;
5716 
5717  current_xmachine_bank_holder = temp_xmachine_bank_holder;
5718  }
5719  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_compute_dividends\n");
5720 
5721  if(FLAME_bank_net_profit_message_board_write == 1)
5722  {
5723 
5724  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bank_net_profit)\n");
5725  rc = MB_SyncStart(b_bank_net_profit);
5726  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bank_net_profit)\n");
5727  #ifdef ERRCHECK
5728  if (rc != MB_SUCCESS)
5729  {
5730  fprintf(stderr, "ERROR: Could not start sync of 'bank_net_profit' board\n");
5731  switch(rc) {
5732  case MB_ERR_INVALID:
5733  fprintf(stderr, "\t reason: 'bank_net_profit' board is invalid\n");
5734  break;
5735  case MB_ERR_LOCKED:
5736  fprintf(stderr, "\t reason: 'bank_net_profit' board is locked\n");
5737  break;
5738  case MB_ERR_MEMALLOC:
5739  fprintf(stderr, "\t reason: out of memory\n");
5740  break;
5741  case MB_ERR_INTERNAL:
5742  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
5743  break;
5744  default:
5745  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
5746  break;
5747  }
5748 
5749 
5750  exit(rc);
5751  }
5752  #endif
5753  }
5754 
5755 
5756 
5757  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
5758  current_xmachine_household_holder = household_HHCreditIsCapitalist_state->agents;
5759  while(current_xmachine_household_holder)
5760  {
5761  temp_xmachine_household_holder = current_xmachine_household_holder->next;
5762  current_xmachine_household = current_xmachine_household_holder->agent;
5763  current_xmachine_household_next_state = household_HHCreditBalanceSheet_state;
5764  /* For backwards compatibility set current_xmachine */
5765  current_xmachine->xmachine_firm = NULL;
5766  current_xmachine->xmachine_household = NULL;
5767  current_xmachine->xmachine_equityfund = NULL;
5768  current_xmachine->xmachine_bank = NULL;
5769  current_xmachine->xmachine_government = NULL;
5770  current_xmachine->xmachine_centralbank = NULL;
5771  current_xmachine->xmachine_jpoffice = NULL;
5772  current_xmachine->xmachine_mall = NULL;
5773  current_xmachine->xmachine_reagency = NULL;
5774  current_xmachine->xmachine_household = current_xmachine_household;
5775 
5776  if(FLAME_condition_household_idle_HHCreditIsCapitalist_HHCreditBalanceSheet(current_xmachine_household)==1)
5777  {
5778 
5779 
5780 
5781  i = idle();
5782 
5783 
5784 
5785  if(i == 1)
5786  {
5787  free_household_agent(current_xmachine_household_holder, household_HHCreditIsCapitalist_state);
5788  }
5789  else
5790  {
5791  transition_household_agent(current_xmachine_household_holder, household_HHCreditIsCapitalist_state, household_HHCreditBalanceSheet_state);
5792  }
5793  }
5794 
5795  current_xmachine_household = NULL;
5796 
5797  current_xmachine_household_holder = temp_xmachine_household_holder;
5798  }
5799  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
5800 
5801 
5802  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_investment_decisions\n");
5803  current_xmachine_firm_holder = firm_FirmCreditInvestment_state->agents;
5804  while(current_xmachine_firm_holder)
5805  {
5806  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
5807  current_xmachine_firm = current_xmachine_firm_holder->agent;
5808  current_xmachine_firm_next_state = firm_FirmCreditComputeDividends_state;
5809  /* For backwards compatibility set current_xmachine */
5810  current_xmachine->xmachine_firm = NULL;
5811  current_xmachine->xmachine_household = NULL;
5812  current_xmachine->xmachine_equityfund = NULL;
5813  current_xmachine->xmachine_bank = NULL;
5814  current_xmachine->xmachine_government = NULL;
5815  current_xmachine->xmachine_centralbank = NULL;
5816  current_xmachine->xmachine_jpoffice = NULL;
5817  current_xmachine->xmachine_mall = NULL;
5818  current_xmachine->xmachine_reagency = NULL;
5819  current_xmachine->xmachine_firm = current_xmachine_firm;
5820 
5821 
5822 
5823 
5824 
5825  i = firm_credit_investment_decisions();
5826 
5827 
5828 
5829  if(i == 1)
5830  {
5831  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditInvestment_state);
5832  }
5833  else
5834  {
5835  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditInvestment_state, firm_FirmCreditComputeDividends_state);
5836  }
5837 
5838 
5839  current_xmachine_firm = NULL;
5840 
5841  current_xmachine_firm_holder = temp_xmachine_firm_holder;
5842  }
5843  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_investment_decisions\n");
5844 
5845 
5846  /* If mb is not read then leave sync complete until last possible moment */
5847  if(FLAME_bank_centralbank_interest_payment_message_board_read == 1)
5848  {
5849  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bank_centralbank_interest_payment)\n");
5850  rc = MB_SyncComplete(b_bank_centralbank_interest_payment);
5851  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bank_centralbank_interest_payment)\n");
5852  #ifdef ERRCHECK
5853  if (rc != MB_SUCCESS)
5854  {
5855  fprintf(stderr, "ERROR: Could not complete sync of 'bank_centralbank_interest_payment' board\n");
5856  switch(rc) {
5857  case MB_ERR_INVALID:
5858  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is invalid\n");
5859  break;
5860  case MB_ERR_MEMALLOC:
5861  fprintf(stderr, "\t reason: out of memory\n");
5862  break;
5863  case MB_ERR_INTERNAL:
5864  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
5865  break;
5866  default:
5867  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
5868  break;
5869  }
5870 
5871 
5872  exit(rc);
5873  }
5874  #endif
5875 
5876 
5877 
5878  }
5879 
5880  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_collect_interest_payments\n");
5881  current_xmachine_centralbank_holder = centralbank_CentralBankCredit_state->agents;
5882  while(current_xmachine_centralbank_holder)
5883  {
5884  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
5885  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
5886  current_xmachine_centralbank_next_state = centralbank_CentralBankDebtRequests_state;
5887  /* For backwards compatibility set current_xmachine */
5888  current_xmachine->xmachine_firm = NULL;
5889  current_xmachine->xmachine_household = NULL;
5890  current_xmachine->xmachine_equityfund = NULL;
5891  current_xmachine->xmachine_bank = NULL;
5892  current_xmachine->xmachine_government = NULL;
5893  current_xmachine->xmachine_centralbank = NULL;
5894  current_xmachine->xmachine_jpoffice = NULL;
5895  current_xmachine->xmachine_mall = NULL;
5896  current_xmachine->xmachine_reagency = NULL;
5897  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
5898 
5899  if(FLAME_condition_centralbank_centralbank_collect_interest_payments_CentralBankCredit_CentralBankDebtRequests(current_xmachine_centralbank)==1)
5900  {
5901 
5902 
5903 
5904 
5905  rc = MB_Iterator_Create(b_bank_centralbank_interest_payment, &i_bank_centralbank_interest_payment);
5906 
5907 
5908  #ifdef ERRCHECK
5909  if (rc != MB_SUCCESS)
5910  {
5911  fprintf(stderr, "ERROR: Could not create Iterator for 'bank_centralbank_interest_payment'\n");
5912  switch(rc) {
5913  case MB_ERR_INVALID:
5914  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is invalid\n");
5915  break;
5916  case MB_ERR_LOCKED:
5917  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is locked\n");
5918  break;
5919  case MB_ERR_MEMALLOC:
5920  fprintf(stderr, "\t reason: out of memory\n");
5921  break;
5922  case MB_ERR_INTERNAL:
5923  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
5924  break;
5925  default:
5926 
5927 
5928  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
5929 
5930  break;
5931  }
5932 
5933 
5934  exit(rc);
5935  }
5936  #endif
5937 
5938 
5939 
5940  i = centralbank_collect_interest_payments();
5941 
5942 
5943  rc = MB_Iterator_Delete(&i_bank_centralbank_interest_payment);
5944  #ifdef ERRCHECK
5945  if (rc != MB_SUCCESS)
5946  {
5947  fprintf(stderr, "ERROR: Could not delete 'bank_centralbank_interest_payment' iterator\n");
5948  switch(rc) {
5949  case MB_ERR_INVALID:
5950  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' iterator is invalid\n");
5951  break;
5952  case MB_ERR_INTERNAL:
5953  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
5954  break;
5955  default:
5956  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
5957  break;
5958  }
5959 
5960 
5961  exit(rc);
5962  }
5963  #endif
5964 
5965 
5966  if(i == 1)
5967  {
5968  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankCredit_state);
5969  }
5970  else
5971  {
5972  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankCredit_state, centralbank_CentralBankDebtRequests_state);
5973  }
5974  }
5975 
5976  current_xmachine_centralbank = NULL;
5977 
5978  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
5979  }
5980  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_collect_interest_payments\n");
5981 
5982 
5983 /* End of layer number 2 */
5984 
5985 /* Clear message boards that have finished being used
5986  * and sync complete if doing late sync complete */
5987 
5988 if(FLAME_bank_centralbank_interest_payment_message_board_read == 0)
5989 {
5990  /*printf("%d> bank_centralbank_interest_payment message board sync complete late as no agents reading any messages of this type\n", node_number);*/
5991 
5992  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bank_centralbank_interest_payment)\n");
5993  rc = MB_SyncComplete(b_bank_centralbank_interest_payment);
5994  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bank_centralbank_interest_payment)\n");
5995  #ifdef ERRCHECK
5996  if (rc != MB_SUCCESS)
5997  {
5998  fprintf(stderr, "ERROR: Could not complete sync of 'bank_centralbank_interest_payment' board\n");
5999  switch(rc) {
6000  case MB_ERR_INVALID:
6001  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is invalid\n");
6002  break;
6003  case MB_ERR_MEMALLOC:
6004  fprintf(stderr, "\t reason: out of memory\n");
6005  break;
6006  case MB_ERR_INTERNAL:
6007  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6008  break;
6009  default:
6010  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
6011  break;
6012  }
6013 
6014 
6015  exit(rc);
6016  }
6017  #endif
6018 }
6019 
6020  /* Delete any search trees */
6021 
6022  rc = MB_Clear(b_bank_centralbank_interest_payment);
6023  #ifdef ERRCHECK
6024  if (rc != MB_SUCCESS)
6025  {
6026  fprintf(stderr, "ERROR: Could not clear 'bank_centralbank_interest_payment' board\n");
6027  switch(rc) {
6028  case MB_ERR_INVALID:
6029  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is invalid\n");
6030  break;
6031  case MB_ERR_LOCKED:
6032  fprintf(stderr, "\t reason: 'bank_centralbank_interest_payment' board is locked\n");
6033  break;
6034  case MB_ERR_INTERNAL:
6035  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6036  break;
6037  default:
6038  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
6039  break;
6040 
6041  }
6042 
6043 
6044  exit(rc);
6045  }
6046  #endif
6047 
6048 
6049  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_do_balance_sheet\n");
6050  current_xmachine_bank_holder = bank_BankCreditBalanceSheet_state->agents;
6051  while(current_xmachine_bank_holder)
6052  {
6053  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
6054  current_xmachine_bank = current_xmachine_bank_holder->agent;
6055  current_xmachine_bank_next_state = bank_BankCreditRequest1_state;
6056  /* For backwards compatibility set current_xmachine */
6057  current_xmachine->xmachine_firm = NULL;
6058  current_xmachine->xmachine_household = NULL;
6059  current_xmachine->xmachine_equityfund = NULL;
6060  current_xmachine->xmachine_bank = NULL;
6061  current_xmachine->xmachine_government = NULL;
6062  current_xmachine->xmachine_centralbank = NULL;
6063  current_xmachine->xmachine_jpoffice = NULL;
6064  current_xmachine->xmachine_mall = NULL;
6065  current_xmachine->xmachine_reagency = NULL;
6066  current_xmachine->xmachine_bank = current_xmachine_bank;
6067 
6068 
6069 
6070 
6071 
6072  i = bank_credit_do_balance_sheet();
6073 
6074 
6075 
6076  if(i == 1)
6077  {
6078  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditBalanceSheet_state);
6079  }
6080  else
6081  {
6082  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditBalanceSheet_state, bank_BankCreditRequest1_state);
6083  }
6084 
6085 
6086  current_xmachine_bank = NULL;
6087 
6088  current_xmachine_bank_holder = temp_xmachine_bank_holder;
6089  }
6090  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_do_balance_sheet\n");
6091 
6092  if(FLAME_bank_centralbank_debt_payment_message_board_write == 1)
6093  {
6094 
6095  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bank_centralbank_debt_payment)\n");
6096  rc = MB_SyncStart(b_bank_centralbank_debt_payment);
6097  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bank_centralbank_debt_payment)\n");
6098  #ifdef ERRCHECK
6099  if (rc != MB_SUCCESS)
6100  {
6101  fprintf(stderr, "ERROR: Could not start sync of 'bank_centralbank_debt_payment' board\n");
6102  switch(rc) {
6103  case MB_ERR_INVALID:
6104  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is invalid\n");
6105  break;
6106  case MB_ERR_LOCKED:
6107  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is locked\n");
6108  break;
6109  case MB_ERR_MEMALLOC:
6110  fprintf(stderr, "\t reason: out of memory\n");
6111  break;
6112  case MB_ERR_INTERNAL:
6113  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6114  break;
6115  default:
6116  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
6117  break;
6118  }
6119 
6120 
6121  exit(rc);
6122  }
6123  #endif
6124  }
6125 
6126 
6127  if(FLAME_debt_request_message_board_write == 1)
6128  {
6129 
6130  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_debt_request)\n");
6131  rc = MB_SyncStart(b_debt_request);
6132  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_debt_request)\n");
6133  #ifdef ERRCHECK
6134  if (rc != MB_SUCCESS)
6135  {
6136  fprintf(stderr, "ERROR: Could not start sync of 'debt_request' board\n");
6137  switch(rc) {
6138  case MB_ERR_INVALID:
6139  fprintf(stderr, "\t reason: 'debt_request' board is invalid\n");
6140  break;
6141  case MB_ERR_LOCKED:
6142  fprintf(stderr, "\t reason: 'debt_request' board is locked\n");
6143  break;
6144  case MB_ERR_MEMALLOC:
6145  fprintf(stderr, "\t reason: out of memory\n");
6146  break;
6147  case MB_ERR_INTERNAL:
6148  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6149  break;
6150  default:
6151  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
6152  break;
6153  }
6154 
6155 
6156  exit(rc);
6157  }
6158  #endif
6159  }
6160 
6161 
6162 
6163  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_compute_dividends\n");
6164  current_xmachine_firm_holder = firm_FirmCreditComputeDividends_state->agents;
6165  while(current_xmachine_firm_holder)
6166  {
6167  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
6168  current_xmachine_firm = current_xmachine_firm_holder->agent;
6169  current_xmachine_firm_next_state = firm_FirmCreditLiquidityNeed_state;
6170  /* For backwards compatibility set current_xmachine */
6171  current_xmachine->xmachine_firm = NULL;
6172  current_xmachine->xmachine_household = NULL;
6173  current_xmachine->xmachine_equityfund = NULL;
6174  current_xmachine->xmachine_bank = NULL;
6175  current_xmachine->xmachine_government = NULL;
6176  current_xmachine->xmachine_centralbank = NULL;
6177  current_xmachine->xmachine_jpoffice = NULL;
6178  current_xmachine->xmachine_mall = NULL;
6179  current_xmachine->xmachine_reagency = NULL;
6180  current_xmachine->xmachine_firm = current_xmachine_firm;
6181 
6182 
6183 
6184 
6185 
6186  i = firm_credit_compute_dividends();
6187 
6188 
6189 
6190  if(i == 1)
6191  {
6192  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditComputeDividends_state);
6193  }
6194  else
6195  {
6196  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditComputeDividends_state, firm_FirmCreditLiquidityNeed_state);
6197  }
6198 
6199 
6200  current_xmachine_firm = NULL;
6201 
6202  current_xmachine_firm_holder = temp_xmachine_firm_holder;
6203  }
6204  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_compute_dividends\n");
6205 
6206 
6207 /* End of layer number 3 */
6208 
6209 /* Clear message boards that have finished being used
6210  * and sync complete if doing late sync complete */
6211 
6212 
6213  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_check_liquidity_need\n");
6214  current_xmachine_firm_holder = firm_FirmCreditLiquidityNeed_state->agents;
6215  while(current_xmachine_firm_holder)
6216  {
6217  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
6218  current_xmachine_firm = current_xmachine_firm_holder->agent;
6219  current_xmachine_firm_next_state = firm_FirmCreditStatus_state;
6220  /* For backwards compatibility set current_xmachine */
6221  current_xmachine->xmachine_firm = NULL;
6222  current_xmachine->xmachine_household = NULL;
6223  current_xmachine->xmachine_equityfund = NULL;
6224  current_xmachine->xmachine_bank = NULL;
6225  current_xmachine->xmachine_government = NULL;
6226  current_xmachine->xmachine_centralbank = NULL;
6227  current_xmachine->xmachine_jpoffice = NULL;
6228  current_xmachine->xmachine_mall = NULL;
6229  current_xmachine->xmachine_reagency = NULL;
6230  current_xmachine->xmachine_firm = current_xmachine_firm;
6231 
6232 
6233 
6234 
6235 
6236  i = firm_credit_check_liquidity_need();
6237 
6238 
6239 
6240  if(i == 1)
6241  {
6242  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLiquidityNeed_state);
6243  }
6244  else
6245  {
6246  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLiquidityNeed_state, firm_FirmCreditStatus_state);
6247  }
6248 
6249 
6250  current_xmachine_firm = NULL;
6251 
6252  current_xmachine_firm_holder = temp_xmachine_firm_holder;
6253  }
6254  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_check_liquidity_need\n");
6255 
6256 
6257  /* If mb is not read then leave sync complete until last possible moment */
6258  if(FLAME_bank_centralbank_debt_payment_message_board_read == 1)
6259  {
6260  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bank_centralbank_debt_payment)\n");
6261  rc = MB_SyncComplete(b_bank_centralbank_debt_payment);
6262  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bank_centralbank_debt_payment)\n");
6263  #ifdef ERRCHECK
6264  if (rc != MB_SUCCESS)
6265  {
6266  fprintf(stderr, "ERROR: Could not complete sync of 'bank_centralbank_debt_payment' board\n");
6267  switch(rc) {
6268  case MB_ERR_INVALID:
6269  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is invalid\n");
6270  break;
6271  case MB_ERR_MEMALLOC:
6272  fprintf(stderr, "\t reason: out of memory\n");
6273  break;
6274  case MB_ERR_INTERNAL:
6275  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6276  break;
6277  default:
6278  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
6279  break;
6280  }
6281 
6282 
6283  exit(rc);
6284  }
6285  #endif
6286 
6287 
6288 
6289  }
6290 
6291  /* If mb is not read then leave sync complete until last possible moment */
6292  if(FLAME_debt_request_message_board_read == 1)
6293  {
6294  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_debt_request)\n");
6295  rc = MB_SyncComplete(b_debt_request);
6296  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_debt_request)\n");
6297  #ifdef ERRCHECK
6298  if (rc != MB_SUCCESS)
6299  {
6300  fprintf(stderr, "ERROR: Could not complete sync of 'debt_request' board\n");
6301  switch(rc) {
6302  case MB_ERR_INVALID:
6303  fprintf(stderr, "\t reason: 'debt_request' board is invalid\n");
6304  break;
6305  case MB_ERR_MEMALLOC:
6306  fprintf(stderr, "\t reason: out of memory\n");
6307  break;
6308  case MB_ERR_INTERNAL:
6309  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6310  break;
6311  default:
6312  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
6313  break;
6314  }
6315 
6316 
6317  exit(rc);
6318  }
6319  #endif
6320 
6321 
6322 
6323  }
6324 
6325  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_process_debt_requests\n");
6326  current_xmachine_centralbank_holder = centralbank_CentralBankDebtRequests_state->agents;
6327  while(current_xmachine_centralbank_holder)
6328  {
6329  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
6330  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
6331  current_xmachine_centralbank_next_state = centralbank_CentralBankIncomeStatement_state;
6332  /* For backwards compatibility set current_xmachine */
6333  current_xmachine->xmachine_firm = NULL;
6334  current_xmachine->xmachine_household = NULL;
6335  current_xmachine->xmachine_equityfund = NULL;
6336  current_xmachine->xmachine_bank = NULL;
6337  current_xmachine->xmachine_government = NULL;
6338  current_xmachine->xmachine_centralbank = NULL;
6339  current_xmachine->xmachine_jpoffice = NULL;
6340  current_xmachine->xmachine_mall = NULL;
6341  current_xmachine->xmachine_reagency = NULL;
6342  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
6343 
6344 
6345 
6346 
6347 
6348 
6349  rc = MB_Iterator_Create(b_debt_request, &i_debt_request);
6350 
6351 
6352  #ifdef ERRCHECK
6353  if (rc != MB_SUCCESS)
6354  {
6355  fprintf(stderr, "ERROR: Could not create Iterator for 'debt_request'\n");
6356  switch(rc) {
6357  case MB_ERR_INVALID:
6358  fprintf(stderr, "\t reason: 'debt_request' board is invalid\n");
6359  break;
6360  case MB_ERR_LOCKED:
6361  fprintf(stderr, "\t reason: 'debt_request' board is locked\n");
6362  break;
6363  case MB_ERR_MEMALLOC:
6364  fprintf(stderr, "\t reason: out of memory\n");
6365  break;
6366  case MB_ERR_INTERNAL:
6367  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6368  break;
6369  default:
6370 
6371 
6372  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
6373 
6374  break;
6375  }
6376 
6377 
6378  exit(rc);
6379  }
6380  #endif
6381 
6382 
6383 
6384 
6385  rc = MB_Iterator_Create(b_bank_centralbank_debt_payment, &i_bank_centralbank_debt_payment);
6386 
6387 
6388  #ifdef ERRCHECK
6389  if (rc != MB_SUCCESS)
6390  {
6391  fprintf(stderr, "ERROR: Could not create Iterator for 'bank_centralbank_debt_payment'\n");
6392  switch(rc) {
6393  case MB_ERR_INVALID:
6394  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is invalid\n");
6395  break;
6396  case MB_ERR_LOCKED:
6397  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is locked\n");
6398  break;
6399  case MB_ERR_MEMALLOC:
6400  fprintf(stderr, "\t reason: out of memory\n");
6401  break;
6402  case MB_ERR_INTERNAL:
6403  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6404  break;
6405  default:
6406 
6407 
6408  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
6409 
6410  break;
6411  }
6412 
6413 
6414  exit(rc);
6415  }
6416  #endif
6417 
6418 
6419 
6420  i = centralbank_process_debt_requests();
6421 
6422 
6423  rc = MB_Iterator_Delete(&i_debt_request);
6424  #ifdef ERRCHECK
6425  if (rc != MB_SUCCESS)
6426  {
6427  fprintf(stderr, "ERROR: Could not delete 'debt_request' iterator\n");
6428  switch(rc) {
6429  case MB_ERR_INVALID:
6430  fprintf(stderr, "\t reason: 'debt_request' iterator is invalid\n");
6431  break;
6432  case MB_ERR_INTERNAL:
6433  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6434  break;
6435  default:
6436  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
6437  break;
6438  }
6439 
6440 
6441  exit(rc);
6442  }
6443  #endif
6444 
6445  rc = MB_Iterator_Delete(&i_bank_centralbank_debt_payment);
6446  #ifdef ERRCHECK
6447  if (rc != MB_SUCCESS)
6448  {
6449  fprintf(stderr, "ERROR: Could not delete 'bank_centralbank_debt_payment' iterator\n");
6450  switch(rc) {
6451  case MB_ERR_INVALID:
6452  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' iterator is invalid\n");
6453  break;
6454  case MB_ERR_INTERNAL:
6455  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6456  break;
6457  default:
6458  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
6459  break;
6460  }
6461 
6462 
6463  exit(rc);
6464  }
6465  #endif
6466 
6467 
6468  if(i == 1)
6469  {
6470  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankDebtRequests_state);
6471  }
6472  else
6473  {
6474  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankDebtRequests_state, centralbank_CentralBankIncomeStatement_state);
6475  }
6476 
6477 
6478  current_xmachine_centralbank = NULL;
6479 
6480  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
6481  }
6482  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_process_debt_requests\n");
6483 
6484 
6485 /* End of layer number 4 */
6486 
6487 /* Clear message boards that have finished being used
6488  * and sync complete if doing late sync complete */
6489 
6490 if(FLAME_debt_request_message_board_read == 0)
6491 {
6492  /*printf("%d> debt_request message board sync complete late as no agents reading any messages of this type\n", node_number);*/
6493 
6494  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_debt_request)\n");
6495  rc = MB_SyncComplete(b_debt_request);
6496  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_debt_request)\n");
6497  #ifdef ERRCHECK
6498  if (rc != MB_SUCCESS)
6499  {
6500  fprintf(stderr, "ERROR: Could not complete sync of 'debt_request' board\n");
6501  switch(rc) {
6502  case MB_ERR_INVALID:
6503  fprintf(stderr, "\t reason: 'debt_request' board is invalid\n");
6504  break;
6505  case MB_ERR_MEMALLOC:
6506  fprintf(stderr, "\t reason: out of memory\n");
6507  break;
6508  case MB_ERR_INTERNAL:
6509  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6510  break;
6511  default:
6512  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
6513  break;
6514  }
6515 
6516 
6517  exit(rc);
6518  }
6519  #endif
6520 }
6521 
6522  /* Delete any search trees */
6523 
6524  rc = MB_Clear(b_debt_request);
6525  #ifdef ERRCHECK
6526  if (rc != MB_SUCCESS)
6527  {
6528  fprintf(stderr, "ERROR: Could not clear 'debt_request' board\n");
6529  switch(rc) {
6530  case MB_ERR_INVALID:
6531  fprintf(stderr, "\t reason: 'debt_request' board is invalid\n");
6532  break;
6533  case MB_ERR_LOCKED:
6534  fprintf(stderr, "\t reason: 'debt_request' board is locked\n");
6535  break;
6536  case MB_ERR_INTERNAL:
6537  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6538  break;
6539  default:
6540  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
6541  break;
6542 
6543  }
6544 
6545 
6546  exit(rc);
6547  }
6548  #endif
6549 
6550 if(FLAME_bank_centralbank_debt_payment_message_board_read == 0)
6551 {
6552  /*printf("%d> bank_centralbank_debt_payment message board sync complete late as no agents reading any messages of this type\n", node_number);*/
6553 
6554  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bank_centralbank_debt_payment)\n");
6555  rc = MB_SyncComplete(b_bank_centralbank_debt_payment);
6556  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bank_centralbank_debt_payment)\n");
6557  #ifdef ERRCHECK
6558  if (rc != MB_SUCCESS)
6559  {
6560  fprintf(stderr, "ERROR: Could not complete sync of 'bank_centralbank_debt_payment' board\n");
6561  switch(rc) {
6562  case MB_ERR_INVALID:
6563  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is invalid\n");
6564  break;
6565  case MB_ERR_MEMALLOC:
6566  fprintf(stderr, "\t reason: out of memory\n");
6567  break;
6568  case MB_ERR_INTERNAL:
6569  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6570  break;
6571  default:
6572  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
6573  break;
6574  }
6575 
6576 
6577  exit(rc);
6578  }
6579  #endif
6580 }
6581 
6582  /* Delete any search trees */
6583 
6584  rc = MB_Clear(b_bank_centralbank_debt_payment);
6585  #ifdef ERRCHECK
6586  if (rc != MB_SUCCESS)
6587  {
6588  fprintf(stderr, "ERROR: Could not clear 'bank_centralbank_debt_payment' board\n");
6589  switch(rc) {
6590  case MB_ERR_INVALID:
6591  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is invalid\n");
6592  break;
6593  case MB_ERR_LOCKED:
6594  fprintf(stderr, "\t reason: 'bank_centralbank_debt_payment' board is locked\n");
6595  break;
6596  case MB_ERR_INTERNAL:
6597  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6598  break;
6599  default:
6600  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
6601  break;
6602 
6603  }
6604 
6605 
6606  exit(rc);
6607  }
6608  #endif
6609 
6610  /* DEBUG: States with branching functions */
6611  current_xmachine_firm_holder = firm_FirmCreditStatus_state->agents;
6612  while(current_xmachine_firm_holder)
6613  {
6614  FLAME_debug_count = 0;
6615  /* Function: firm_credit_demand_loans_1 */
6616  if(FLAME_condition_firm_firm_credit_demand_loans_1_FirmCreditStatus_FirmCreditLoanBorrow1(current_xmachine_firm_holder->agent)==1)
6617  { FLAME_debug_count++; }
6618  /* Function: idle */
6619  if(FLAME_condition_firm_idle_FirmCreditStatus_FirmCreditPayments(current_xmachine_firm_holder->agent)==1)
6620  { FLAME_debug_count++; }
6621  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
6622  if(FLAME_debug_count != 1)
6623  {
6624  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmCreditStatus'\n");
6625  if(FLAME_debug_count > 1)
6626  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
6627  if(FLAME_debug_count == 0)
6628  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
6629  }
6630 
6631  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
6632  }
6633 
6634  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_demand_loans_1\n");
6635  current_xmachine_firm_holder = firm_FirmCreditStatus_state->agents;
6636  while(current_xmachine_firm_holder)
6637  {
6638  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
6639  current_xmachine_firm = current_xmachine_firm_holder->agent;
6640  current_xmachine_firm_next_state = firm_FirmCreditLoanBorrow1_state;
6641  /* For backwards compatibility set current_xmachine */
6642  current_xmachine->xmachine_firm = NULL;
6643  current_xmachine->xmachine_household = NULL;
6644  current_xmachine->xmachine_equityfund = NULL;
6645  current_xmachine->xmachine_bank = NULL;
6646  current_xmachine->xmachine_government = NULL;
6647  current_xmachine->xmachine_centralbank = NULL;
6648  current_xmachine->xmachine_jpoffice = NULL;
6649  current_xmachine->xmachine_mall = NULL;
6650  current_xmachine->xmachine_reagency = NULL;
6651  current_xmachine->xmachine_firm = current_xmachine_firm;
6652 
6653  if(FLAME_condition_firm_firm_credit_demand_loans_1_FirmCreditStatus_FirmCreditLoanBorrow1(current_xmachine_firm)==1)
6654  {
6655 
6656 
6657 
6658  i = firm_credit_demand_loans_1();
6659 
6660 
6661 
6662  if(i == 1)
6663  {
6664  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStatus_state);
6665  }
6666  else
6667  {
6668  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStatus_state, firm_FirmCreditLoanBorrow1_state);
6669  }
6670  }
6671 
6672  current_xmachine_firm = NULL;
6673 
6674  current_xmachine_firm_holder = temp_xmachine_firm_holder;
6675  }
6676  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_demand_loans_1\n");
6677 
6678  if(FLAME_loan_request_1_message_board_write == 1)
6679  {
6680 
6681  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_request_1)\n");
6682  rc = MB_SyncStart(b_loan_request_1);
6683  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_request_1)\n");
6684  #ifdef ERRCHECK
6685  if (rc != MB_SUCCESS)
6686  {
6687  fprintf(stderr, "ERROR: Could not start sync of 'loan_request_1' board\n");
6688  switch(rc) {
6689  case MB_ERR_INVALID:
6690  fprintf(stderr, "\t reason: 'loan_request_1' board is invalid\n");
6691  break;
6692  case MB_ERR_LOCKED:
6693  fprintf(stderr, "\t reason: 'loan_request_1' board is locked\n");
6694  break;
6695  case MB_ERR_MEMALLOC:
6696  fprintf(stderr, "\t reason: out of memory\n");
6697  break;
6698  case MB_ERR_INTERNAL:
6699  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6700  break;
6701  default:
6702  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
6703  break;
6704  }
6705 
6706 
6707  exit(rc);
6708  }
6709  #endif
6710  }
6711 
6712 
6713 
6714  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_compute_income_statement\n");
6715  current_xmachine_centralbank_holder = centralbank_CentralBankIncomeStatement_state->agents;
6716  while(current_xmachine_centralbank_holder)
6717  {
6718  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
6719  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
6720  current_xmachine_centralbank_next_state = centralbank_CentralBankBalanceSheet_state;
6721  /* For backwards compatibility set current_xmachine */
6722  current_xmachine->xmachine_firm = NULL;
6723  current_xmachine->xmachine_household = NULL;
6724  current_xmachine->xmachine_equityfund = NULL;
6725  current_xmachine->xmachine_bank = NULL;
6726  current_xmachine->xmachine_government = NULL;
6727  current_xmachine->xmachine_centralbank = NULL;
6728  current_xmachine->xmachine_jpoffice = NULL;
6729  current_xmachine->xmachine_mall = NULL;
6730  current_xmachine->xmachine_reagency = NULL;
6731  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
6732 
6733 
6734 
6735 
6736 
6737  i = centralbank_compute_income_statement();
6738 
6739 
6740 
6741  if(i == 1)
6742  {
6743  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankIncomeStatement_state);
6744  }
6745  else
6746  {
6747  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankIncomeStatement_state, centralbank_CentralBankBalanceSheet_state);
6748  }
6749 
6750 
6751  current_xmachine_centralbank = NULL;
6752 
6753  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
6754  }
6755  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_compute_income_statement\n");
6756 
6757  if(FLAME_centralbank_government_profit_message_board_write == 1)
6758  {
6759 
6760  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_centralbank_government_profit)\n");
6761  rc = MB_SyncStart(b_centralbank_government_profit);
6762  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_centralbank_government_profit)\n");
6763  #ifdef ERRCHECK
6764  if (rc != MB_SUCCESS)
6765  {
6766  fprintf(stderr, "ERROR: Could not start sync of 'centralbank_government_profit' board\n");
6767  switch(rc) {
6768  case MB_ERR_INVALID:
6769  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is invalid\n");
6770  break;
6771  case MB_ERR_LOCKED:
6772  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is locked\n");
6773  break;
6774  case MB_ERR_MEMALLOC:
6775  fprintf(stderr, "\t reason: out of memory\n");
6776  break;
6777  case MB_ERR_INTERNAL:
6778  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6779  break;
6780  default:
6781  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
6782  break;
6783  }
6784 
6785 
6786  exit(rc);
6787  }
6788  #endif
6789  }
6790 
6791 
6792 
6793  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
6794  current_xmachine_firm_holder = firm_FirmCreditStatus_state->agents;
6795  while(current_xmachine_firm_holder)
6796  {
6797  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
6798  current_xmachine_firm = current_xmachine_firm_holder->agent;
6799  current_xmachine_firm_next_state = firm_FirmCreditPayments_state;
6800  /* For backwards compatibility set current_xmachine */
6801  current_xmachine->xmachine_firm = NULL;
6802  current_xmachine->xmachine_household = NULL;
6803  current_xmachine->xmachine_equityfund = NULL;
6804  current_xmachine->xmachine_bank = NULL;
6805  current_xmachine->xmachine_government = NULL;
6806  current_xmachine->xmachine_centralbank = NULL;
6807  current_xmachine->xmachine_jpoffice = NULL;
6808  current_xmachine->xmachine_mall = NULL;
6809  current_xmachine->xmachine_reagency = NULL;
6810  current_xmachine->xmachine_firm = current_xmachine_firm;
6811 
6812  if(FLAME_condition_firm_idle_FirmCreditStatus_FirmCreditPayments(current_xmachine_firm)==1)
6813  {
6814 
6815 
6816 
6817  i = idle();
6818 
6819 
6820 
6821  if(i == 1)
6822  {
6823  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStatus_state);
6824  }
6825  else
6826  {
6827  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditStatus_state, firm_FirmCreditPayments_state);
6828  }
6829  }
6830 
6831  current_xmachine_firm = NULL;
6832 
6833  current_xmachine_firm_holder = temp_xmachine_firm_holder;
6834  }
6835  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
6836 
6837 
6838 /* End of layer number 5 */
6839 
6840 /* Clear message boards that have finished being used
6841  * and sync complete if doing late sync complete */
6842 
6843 
6844  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_do_balance_sheet\n");
6845  current_xmachine_centralbank_holder = centralbank_CentralBankBalanceSheet_state->agents;
6846  while(current_xmachine_centralbank_holder)
6847  {
6848  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
6849  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
6850  current_xmachine_centralbank_next_state = centralbank_CentralBankInterestRate_state;
6851  /* For backwards compatibility set current_xmachine */
6852  current_xmachine->xmachine_firm = NULL;
6853  current_xmachine->xmachine_household = NULL;
6854  current_xmachine->xmachine_equityfund = NULL;
6855  current_xmachine->xmachine_bank = NULL;
6856  current_xmachine->xmachine_government = NULL;
6857  current_xmachine->xmachine_centralbank = NULL;
6858  current_xmachine->xmachine_jpoffice = NULL;
6859  current_xmachine->xmachine_mall = NULL;
6860  current_xmachine->xmachine_reagency = NULL;
6861  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
6862 
6863 
6864 
6865 
6866 
6867  i = centralbank_do_balance_sheet();
6868 
6869 
6870 
6871  if(i == 1)
6872  {
6873  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankBalanceSheet_state);
6874  }
6875  else
6876  {
6877  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankBalanceSheet_state, centralbank_CentralBankInterestRate_state);
6878  }
6879 
6880 
6881  current_xmachine_centralbank = NULL;
6882 
6883  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
6884  }
6885  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_do_balance_sheet\n");
6886 
6887 
6888  /* If mb is not read then leave sync complete until last possible moment */
6889  if(FLAME_loan_request_1_message_board_read == 1)
6890  {
6891  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_request_1)\n");
6892  rc = MB_SyncComplete(b_loan_request_1);
6893  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_request_1)\n");
6894  #ifdef ERRCHECK
6895  if (rc != MB_SUCCESS)
6896  {
6897  fprintf(stderr, "ERROR: Could not complete sync of 'loan_request_1' board\n");
6898  switch(rc) {
6899  case MB_ERR_INVALID:
6900  fprintf(stderr, "\t reason: 'loan_request_1' board is invalid\n");
6901  break;
6902  case MB_ERR_MEMALLOC:
6903  fprintf(stderr, "\t reason: out of memory\n");
6904  break;
6905  case MB_ERR_INTERNAL:
6906  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6907  break;
6908  default:
6909  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
6910  break;
6911  }
6912 
6913 
6914  exit(rc);
6915  }
6916  #endif
6917 
6918 
6919 
6920  }
6921 
6922  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_process_loan_requests_1\n");
6923  current_xmachine_bank_holder = bank_BankCreditRequest1_state->agents;
6924  while(current_xmachine_bank_holder)
6925  {
6926  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
6927  current_xmachine_bank = current_xmachine_bank_holder->agent;
6928  current_xmachine_bank_next_state = bank_BankCreditRequest2_state;
6929  /* For backwards compatibility set current_xmachine */
6930  current_xmachine->xmachine_firm = NULL;
6931  current_xmachine->xmachine_household = NULL;
6932  current_xmachine->xmachine_equityfund = NULL;
6933  current_xmachine->xmachine_bank = NULL;
6934  current_xmachine->xmachine_government = NULL;
6935  current_xmachine->xmachine_centralbank = NULL;
6936  current_xmachine->xmachine_jpoffice = NULL;
6937  current_xmachine->xmachine_mall = NULL;
6938  current_xmachine->xmachine_reagency = NULL;
6939  current_xmachine->xmachine_bank = current_xmachine_bank;
6940 
6941 
6942 
6943 
6944 
6945 
6946 
6947 
6948  rc = MB_Iterator_CreateFiltered(b_loan_request_1, &i_loan_request_1, &FLAME_filter_bank_bank_credit_process_loan_requests_1_BankCreditRequest1_BankCreditRequest2_loan_request_1, current_xmachine_bank);
6949 
6950 
6951 
6952  #ifdef ERRCHECK
6953  if (rc != MB_SUCCESS)
6954  {
6955  fprintf(stderr, "ERROR: Could not create Iterator for 'loan_request_1'\n");
6956  switch(rc) {
6957  case MB_ERR_INVALID:
6958  fprintf(stderr, "\t reason: 'loan_request_1' board is invalid\n");
6959  break;
6960  case MB_ERR_LOCKED:
6961  fprintf(stderr, "\t reason: 'loan_request_1' board is locked\n");
6962  break;
6963  case MB_ERR_MEMALLOC:
6964  fprintf(stderr, "\t reason: out of memory\n");
6965  break;
6966  case MB_ERR_INTERNAL:
6967  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6968  break;
6969  default:
6970 
6971  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
6972 
6973 
6974  break;
6975  }
6976 
6977 
6978  exit(rc);
6979  }
6980  #endif
6981 
6982 
6983 
6984  i = bank_credit_process_loan_requests_1();
6985 
6986 
6987  rc = MB_Iterator_Delete(&i_loan_request_1);
6988  #ifdef ERRCHECK
6989  if (rc != MB_SUCCESS)
6990  {
6991  fprintf(stderr, "ERROR: Could not delete 'loan_request_1' iterator\n");
6992  switch(rc) {
6993  case MB_ERR_INVALID:
6994  fprintf(stderr, "\t reason: 'loan_request_1' iterator is invalid\n");
6995  break;
6996  case MB_ERR_INTERNAL:
6997  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
6998  break;
6999  default:
7000  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
7001  break;
7002  }
7003 
7004 
7005  exit(rc);
7006  }
7007  #endif
7008 
7009 
7010  if(i == 1)
7011  {
7012  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditRequest1_state);
7013  }
7014  else
7015  {
7016  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditRequest1_state, bank_BankCreditRequest2_state);
7017  }
7018 
7019 
7020  current_xmachine_bank = NULL;
7021 
7022  current_xmachine_bank_holder = temp_xmachine_bank_holder;
7023  }
7024  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_process_loan_requests_1\n");
7025 
7026  if(FLAME_loan_acknowledge_1_message_board_write == 1)
7027  {
7028 
7029  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_acknowledge_1)\n");
7030  rc = MB_SyncStart(b_loan_acknowledge_1);
7031  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_acknowledge_1)\n");
7032  #ifdef ERRCHECK
7033  if (rc != MB_SUCCESS)
7034  {
7035  fprintf(stderr, "ERROR: Could not start sync of 'loan_acknowledge_1' board\n");
7036  switch(rc) {
7037  case MB_ERR_INVALID:
7038  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is invalid\n");
7039  break;
7040  case MB_ERR_LOCKED:
7041  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is locked\n");
7042  break;
7043  case MB_ERR_MEMALLOC:
7044  fprintf(stderr, "\t reason: out of memory\n");
7045  break;
7046  case MB_ERR_INTERNAL:
7047  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7048  break;
7049  default:
7050  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
7051  break;
7052  }
7053 
7054 
7055  exit(rc);
7056  }
7057  #endif
7058  }
7059 
7060 
7061 
7062 /* End of layer number 6 */
7063 
7064 /* Clear message boards that have finished being used
7065  * and sync complete if doing late sync complete */
7066 
7067 if(FLAME_loan_request_1_message_board_read == 0)
7068 {
7069  /*printf("%d> loan_request_1 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
7070 
7071  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_request_1)\n");
7072  rc = MB_SyncComplete(b_loan_request_1);
7073  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_request_1)\n");
7074  #ifdef ERRCHECK
7075  if (rc != MB_SUCCESS)
7076  {
7077  fprintf(stderr, "ERROR: Could not complete sync of 'loan_request_1' board\n");
7078  switch(rc) {
7079  case MB_ERR_INVALID:
7080  fprintf(stderr, "\t reason: 'loan_request_1' board is invalid\n");
7081  break;
7082  case MB_ERR_MEMALLOC:
7083  fprintf(stderr, "\t reason: out of memory\n");
7084  break;
7085  case MB_ERR_INTERNAL:
7086  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7087  break;
7088  default:
7089  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
7090  break;
7091  }
7092 
7093 
7094  exit(rc);
7095  }
7096  #endif
7097 }
7098 
7099  /* Delete any search trees */
7100 
7101  rc = MB_Clear(b_loan_request_1);
7102  #ifdef ERRCHECK
7103  if (rc != MB_SUCCESS)
7104  {
7105  fprintf(stderr, "ERROR: Could not clear 'loan_request_1' board\n");
7106  switch(rc) {
7107  case MB_ERR_INVALID:
7108  fprintf(stderr, "\t reason: 'loan_request_1' board is invalid\n");
7109  break;
7110  case MB_ERR_LOCKED:
7111  fprintf(stderr, "\t reason: 'loan_request_1' board is locked\n");
7112  break;
7113  case MB_ERR_INTERNAL:
7114  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7115  break;
7116  default:
7117  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
7118  break;
7119 
7120  }
7121 
7122 
7123  exit(rc);
7124  }
7125  #endif
7126 
7127 
7128  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_set_interest_rate\n");
7129  current_xmachine_centralbank_holder = centralbank_CentralBankInterestRate_state->agents;
7130  while(current_xmachine_centralbank_holder)
7131  {
7132  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
7133  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
7134  current_xmachine_centralbank_next_state = centralbank_CentralBankLabour_state;
7135  /* For backwards compatibility set current_xmachine */
7136  current_xmachine->xmachine_firm = NULL;
7137  current_xmachine->xmachine_household = NULL;
7138  current_xmachine->xmachine_equityfund = NULL;
7139  current_xmachine->xmachine_bank = NULL;
7140  current_xmachine->xmachine_government = NULL;
7141  current_xmachine->xmachine_centralbank = NULL;
7142  current_xmachine->xmachine_jpoffice = NULL;
7143  current_xmachine->xmachine_mall = NULL;
7144  current_xmachine->xmachine_reagency = NULL;
7145  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
7146 
7147 
7148 
7149 
7150 
7151  i = centralbank_set_interest_rate();
7152 
7153 
7154 
7155  if(i == 1)
7156  {
7157  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankInterestRate_state);
7158  }
7159  else
7160  {
7161  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankInterestRate_state, centralbank_CentralBankLabour_state);
7162  }
7163 
7164 
7165  current_xmachine_centralbank = NULL;
7166 
7167  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
7168  }
7169  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_set_interest_rate\n");
7170 
7171  if(FLAME_interest_rate_message_board_write == 1)
7172  {
7173 
7174  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_interest_rate)\n");
7175  rc = MB_SyncStart(b_interest_rate);
7176  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_interest_rate)\n");
7177  #ifdef ERRCHECK
7178  if (rc != MB_SUCCESS)
7179  {
7180  fprintf(stderr, "ERROR: Could not start sync of 'interest_rate' board\n");
7181  switch(rc) {
7182  case MB_ERR_INVALID:
7183  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
7184  break;
7185  case MB_ERR_LOCKED:
7186  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
7187  break;
7188  case MB_ERR_MEMALLOC:
7189  fprintf(stderr, "\t reason: out of memory\n");
7190  break;
7191  case MB_ERR_INTERNAL:
7192  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7193  break;
7194  default:
7195  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
7196  break;
7197  }
7198 
7199 
7200  exit(rc);
7201  }
7202  #endif
7203  }
7204 
7205 
7206 
7207  /* If mb is not read then leave sync complete until last possible moment */
7208  if(FLAME_loan_acknowledge_1_message_board_read == 1)
7209  {
7210  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_acknowledge_1)\n");
7211  rc = MB_SyncComplete(b_loan_acknowledge_1);
7212  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_acknowledge_1)\n");
7213  #ifdef ERRCHECK
7214  if (rc != MB_SUCCESS)
7215  {
7216  fprintf(stderr, "ERROR: Could not complete sync of 'loan_acknowledge_1' board\n");
7217  switch(rc) {
7218  case MB_ERR_INVALID:
7219  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is invalid\n");
7220  break;
7221  case MB_ERR_MEMALLOC:
7222  fprintf(stderr, "\t reason: out of memory\n");
7223  break;
7224  case MB_ERR_INTERNAL:
7225  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7226  break;
7227  default:
7228  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
7229  break;
7230  }
7231 
7232 
7233  exit(rc);
7234  }
7235  #endif
7236 
7237 
7238 
7239  }
7240 
7241  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_borrow_loans_1\n");
7242  current_xmachine_firm_holder = firm_FirmCreditLoanBorrow1_state->agents;
7243  while(current_xmachine_firm_holder)
7244  {
7245  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
7246  current_xmachine_firm = current_xmachine_firm_holder->agent;
7247  current_xmachine_firm_next_state = firm_FirmCreditLoanBorrow2_state;
7248  /* For backwards compatibility set current_xmachine */
7249  current_xmachine->xmachine_firm = NULL;
7250  current_xmachine->xmachine_household = NULL;
7251  current_xmachine->xmachine_equityfund = NULL;
7252  current_xmachine->xmachine_bank = NULL;
7253  current_xmachine->xmachine_government = NULL;
7254  current_xmachine->xmachine_centralbank = NULL;
7255  current_xmachine->xmachine_jpoffice = NULL;
7256  current_xmachine->xmachine_mall = NULL;
7257  current_xmachine->xmachine_reagency = NULL;
7258  current_xmachine->xmachine_firm = current_xmachine_firm;
7259 
7260 
7261 
7262 
7263 
7264 
7265 
7266 
7267  rc = MB_Iterator_CreateFiltered(b_loan_acknowledge_1, &i_loan_acknowledge_1, &FLAME_filter_firm_firm_credit_borrow_loans_1_FirmCreditLoanBorrow1_FirmCreditLoanBorrow2_loan_acknowledge_1, current_xmachine_firm);
7268 
7269 
7270 
7271  #ifdef ERRCHECK
7272  if (rc != MB_SUCCESS)
7273  {
7274  fprintf(stderr, "ERROR: Could not create Iterator for 'loan_acknowledge_1'\n");
7275  switch(rc) {
7276  case MB_ERR_INVALID:
7277  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is invalid\n");
7278  break;
7279  case MB_ERR_LOCKED:
7280  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is locked\n");
7281  break;
7282  case MB_ERR_MEMALLOC:
7283  fprintf(stderr, "\t reason: out of memory\n");
7284  break;
7285  case MB_ERR_INTERNAL:
7286  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7287  break;
7288  default:
7289 
7290  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
7291 
7292 
7293  break;
7294  }
7295 
7296 
7297  exit(rc);
7298  }
7299  #endif
7300 
7301 
7302 
7303  i = firm_credit_borrow_loans_1();
7304 
7305 
7306  rc = MB_Iterator_Delete(&i_loan_acknowledge_1);
7307  #ifdef ERRCHECK
7308  if (rc != MB_SUCCESS)
7309  {
7310  fprintf(stderr, "ERROR: Could not delete 'loan_acknowledge_1' iterator\n");
7311  switch(rc) {
7312  case MB_ERR_INVALID:
7313  fprintf(stderr, "\t reason: 'loan_acknowledge_1' iterator is invalid\n");
7314  break;
7315  case MB_ERR_INTERNAL:
7316  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7317  break;
7318  default:
7319  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
7320  break;
7321  }
7322 
7323 
7324  exit(rc);
7325  }
7326  #endif
7327 
7328 
7329  if(i == 1)
7330  {
7331  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLoanBorrow1_state);
7332  }
7333  else
7334  {
7335  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLoanBorrow1_state, firm_FirmCreditLoanBorrow2_state);
7336  }
7337 
7338 
7339  current_xmachine_firm = NULL;
7340 
7341  current_xmachine_firm_holder = temp_xmachine_firm_holder;
7342  }
7343  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_borrow_loans_1\n");
7344 
7345  if(FLAME_loan_request_2_message_board_write == 1)
7346  {
7347 
7348  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_request_2)\n");
7349  rc = MB_SyncStart(b_loan_request_2);
7350  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_request_2)\n");
7351  #ifdef ERRCHECK
7352  if (rc != MB_SUCCESS)
7353  {
7354  fprintf(stderr, "ERROR: Could not start sync of 'loan_request_2' board\n");
7355  switch(rc) {
7356  case MB_ERR_INVALID:
7357  fprintf(stderr, "\t reason: 'loan_request_2' board is invalid\n");
7358  break;
7359  case MB_ERR_LOCKED:
7360  fprintf(stderr, "\t reason: 'loan_request_2' board is locked\n");
7361  break;
7362  case MB_ERR_MEMALLOC:
7363  fprintf(stderr, "\t reason: out of memory\n");
7364  break;
7365  case MB_ERR_INTERNAL:
7366  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7367  break;
7368  default:
7369  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
7370  break;
7371  }
7372 
7373 
7374  exit(rc);
7375  }
7376  #endif
7377  }
7378 
7379 
7380 
7381 /* End of layer number 7 */
7382 
7383 /* Clear message boards that have finished being used
7384  * and sync complete if doing late sync complete */
7385 
7386 if(FLAME_loan_acknowledge_1_message_board_read == 0)
7387 {
7388  /*printf("%d> loan_acknowledge_1 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
7389 
7390  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_acknowledge_1)\n");
7391  rc = MB_SyncComplete(b_loan_acknowledge_1);
7392  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_acknowledge_1)\n");
7393  #ifdef ERRCHECK
7394  if (rc != MB_SUCCESS)
7395  {
7396  fprintf(stderr, "ERROR: Could not complete sync of 'loan_acknowledge_1' board\n");
7397  switch(rc) {
7398  case MB_ERR_INVALID:
7399  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is invalid\n");
7400  break;
7401  case MB_ERR_MEMALLOC:
7402  fprintf(stderr, "\t reason: out of memory\n");
7403  break;
7404  case MB_ERR_INTERNAL:
7405  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7406  break;
7407  default:
7408  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
7409  break;
7410  }
7411 
7412 
7413  exit(rc);
7414  }
7415  #endif
7416 }
7417 
7418  /* Delete any search trees */
7419 
7420  rc = MB_Clear(b_loan_acknowledge_1);
7421  #ifdef ERRCHECK
7422  if (rc != MB_SUCCESS)
7423  {
7424  fprintf(stderr, "ERROR: Could not clear 'loan_acknowledge_1' board\n");
7425  switch(rc) {
7426  case MB_ERR_INVALID:
7427  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is invalid\n");
7428  break;
7429  case MB_ERR_LOCKED:
7430  fprintf(stderr, "\t reason: 'loan_acknowledge_1' board is locked\n");
7431  break;
7432  case MB_ERR_INTERNAL:
7433  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7434  break;
7435  default:
7436  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
7437  break;
7438 
7439  }
7440 
7441 
7442  exit(rc);
7443  }
7444  #endif
7445 
7446  /* DEBUG: States with branching functions */
7447  current_xmachine_firm_holder = firm_FirmCreditLoanBorrow2_state->agents;
7448  while(current_xmachine_firm_holder)
7449  {
7450  FLAME_debug_count = 0;
7451  /* Function: firm_credit_borrow_loans_2 */
7452  if(FLAME_condition_firm_firm_credit_borrow_loans_2_FirmCreditLoanBorrow2_FirmCreditIlliquidityStatus(current_xmachine_firm_holder->agent)==1)
7453  { FLAME_debug_count++; }
7454  /* Function: idle */
7455  if(FLAME_condition_firm_idle_FirmCreditLoanBorrow2_FirmCreditPayments(current_xmachine_firm_holder->agent)==1)
7456  { FLAME_debug_count++; }
7457  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
7458  if(FLAME_debug_count != 1)
7459  {
7460  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmCreditLoanBorrow2'\n");
7461  if(FLAME_debug_count > 1)
7462  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
7463  if(FLAME_debug_count == 0)
7464  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
7465  }
7466 
7467  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
7468  }
7469  /* DEBUG: States with branching functions */
7470  current_xmachine_centralbank_holder = centralbank_CentralBankLabour_state->agents;
7471  while(current_xmachine_centralbank_holder)
7472  {
7473  FLAME_debug_count = 0;
7474  /* Function: centralbank_trace_unemployment_status */
7475  if(FLAME_condition_centralbank_centralbank_trace_unemployment_status_CentralBankLabour_CentralBankConsumption(current_xmachine_centralbank_holder->agent)==1)
7476  { FLAME_debug_count++; }
7477  /* Function: idle */
7478  if(FLAME_condition_centralbank_idle_CentralBankLabour_CentralBankConsumption(current_xmachine_centralbank_holder->agent)==1)
7479  { FLAME_debug_count++; }
7480  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
7481  if(FLAME_debug_count != 1)
7482  {
7483  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'centralbank' leaving state 'CentralBankLabour'\n");
7484  if(FLAME_debug_count > 1)
7485  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
7486  if(FLAME_debug_count == 0)
7487  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
7488  }
7489 
7490  current_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
7491  }
7492 
7493  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
7494  current_xmachine_centralbank_holder = centralbank_CentralBankLabour_state->agents;
7495  while(current_xmachine_centralbank_holder)
7496  {
7497  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
7498  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
7499  current_xmachine_centralbank_next_state = centralbank_CentralBankConsumption_state;
7500  /* For backwards compatibility set current_xmachine */
7501  current_xmachine->xmachine_firm = NULL;
7502  current_xmachine->xmachine_household = NULL;
7503  current_xmachine->xmachine_equityfund = NULL;
7504  current_xmachine->xmachine_bank = NULL;
7505  current_xmachine->xmachine_government = NULL;
7506  current_xmachine->xmachine_centralbank = NULL;
7507  current_xmachine->xmachine_jpoffice = NULL;
7508  current_xmachine->xmachine_mall = NULL;
7509  current_xmachine->xmachine_reagency = NULL;
7510  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
7511 
7512  if(FLAME_condition_centralbank_idle_CentralBankLabour_CentralBankConsumption(current_xmachine_centralbank)==1)
7513  {
7514 
7515 
7516 
7517  i = idle();
7518 
7519 
7520 
7521  if(i == 1)
7522  {
7523  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankLabour_state);
7524  }
7525  else
7526  {
7527  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankLabour_state, centralbank_CentralBankConsumption_state);
7528  }
7529  }
7530 
7531  current_xmachine_centralbank = NULL;
7532 
7533  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
7534  }
7535  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
7536 
7537 
7538  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
7539  current_xmachine_firm_holder = firm_FirmCreditLoanBorrow2_state->agents;
7540  while(current_xmachine_firm_holder)
7541  {
7542  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
7543  current_xmachine_firm = current_xmachine_firm_holder->agent;
7544  current_xmachine_firm_next_state = firm_FirmCreditPayments_state;
7545  /* For backwards compatibility set current_xmachine */
7546  current_xmachine->xmachine_firm = NULL;
7547  current_xmachine->xmachine_household = NULL;
7548  current_xmachine->xmachine_equityfund = NULL;
7549  current_xmachine->xmachine_bank = NULL;
7550  current_xmachine->xmachine_government = NULL;
7551  current_xmachine->xmachine_centralbank = NULL;
7552  current_xmachine->xmachine_jpoffice = NULL;
7553  current_xmachine->xmachine_mall = NULL;
7554  current_xmachine->xmachine_reagency = NULL;
7555  current_xmachine->xmachine_firm = current_xmachine_firm;
7556 
7557  if(FLAME_condition_firm_idle_FirmCreditLoanBorrow2_FirmCreditPayments(current_xmachine_firm)==1)
7558  {
7559 
7560 
7561 
7562  i = idle();
7563 
7564 
7565 
7566  if(i == 1)
7567  {
7568  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLoanBorrow2_state);
7569  }
7570  else
7571  {
7572  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLoanBorrow2_state, firm_FirmCreditPayments_state);
7573  }
7574  }
7575 
7576  current_xmachine_firm = NULL;
7577 
7578  current_xmachine_firm_holder = temp_xmachine_firm_holder;
7579  }
7580  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
7581 
7582 
7583  /* If mb is not read then leave sync complete until last possible moment */
7584  if(FLAME_loan_request_2_message_board_read == 1)
7585  {
7586  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_request_2)\n");
7587  rc = MB_SyncComplete(b_loan_request_2);
7588  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_request_2)\n");
7589  #ifdef ERRCHECK
7590  if (rc != MB_SUCCESS)
7591  {
7592  fprintf(stderr, "ERROR: Could not complete sync of 'loan_request_2' board\n");
7593  switch(rc) {
7594  case MB_ERR_INVALID:
7595  fprintf(stderr, "\t reason: 'loan_request_2' board is invalid\n");
7596  break;
7597  case MB_ERR_MEMALLOC:
7598  fprintf(stderr, "\t reason: out of memory\n");
7599  break;
7600  case MB_ERR_INTERNAL:
7601  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7602  break;
7603  default:
7604  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
7605  break;
7606  }
7607 
7608 
7609  exit(rc);
7610  }
7611  #endif
7612 
7613 
7614 
7615  }
7616 
7617  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_process_loan_requests_2\n");
7618  current_xmachine_bank_holder = bank_BankCreditRequest2_state->agents;
7619  while(current_xmachine_bank_holder)
7620  {
7621  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
7622  current_xmachine_bank = current_xmachine_bank_holder->agent;
7623  current_xmachine_bank_next_state = bank_BankCreditLoanWriteOffs_state;
7624  /* For backwards compatibility set current_xmachine */
7625  current_xmachine->xmachine_firm = NULL;
7626  current_xmachine->xmachine_household = NULL;
7627  current_xmachine->xmachine_equityfund = NULL;
7628  current_xmachine->xmachine_bank = NULL;
7629  current_xmachine->xmachine_government = NULL;
7630  current_xmachine->xmachine_centralbank = NULL;
7631  current_xmachine->xmachine_jpoffice = NULL;
7632  current_xmachine->xmachine_mall = NULL;
7633  current_xmachine->xmachine_reagency = NULL;
7634  current_xmachine->xmachine_bank = current_xmachine_bank;
7635 
7636 
7637 
7638 
7639 
7640 
7641  rc = MB_Iterator_Create(b_loan_request_2, &i_loan_request_2);
7642 
7643 
7644  #ifdef ERRCHECK
7645  if (rc != MB_SUCCESS)
7646  {
7647  fprintf(stderr, "ERROR: Could not create Iterator for 'loan_request_2'\n");
7648  switch(rc) {
7649  case MB_ERR_INVALID:
7650  fprintf(stderr, "\t reason: 'loan_request_2' board is invalid\n");
7651  break;
7652  case MB_ERR_LOCKED:
7653  fprintf(stderr, "\t reason: 'loan_request_2' board is locked\n");
7654  break;
7655  case MB_ERR_MEMALLOC:
7656  fprintf(stderr, "\t reason: out of memory\n");
7657  break;
7658  case MB_ERR_INTERNAL:
7659  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7660  break;
7661  default:
7662 
7663 
7664  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
7665 
7666  break;
7667  }
7668 
7669 
7670  exit(rc);
7671  }
7672  #endif
7673 
7674 
7675 
7676  i = bank_credit_process_loan_requests_2();
7677 
7678 
7679  rc = MB_Iterator_Delete(&i_loan_request_2);
7680  #ifdef ERRCHECK
7681  if (rc != MB_SUCCESS)
7682  {
7683  fprintf(stderr, "ERROR: Could not delete 'loan_request_2' iterator\n");
7684  switch(rc) {
7685  case MB_ERR_INVALID:
7686  fprintf(stderr, "\t reason: 'loan_request_2' iterator is invalid\n");
7687  break;
7688  case MB_ERR_INTERNAL:
7689  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7690  break;
7691  default:
7692  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
7693  break;
7694  }
7695 
7696 
7697  exit(rc);
7698  }
7699  #endif
7700 
7701 
7702  if(i == 1)
7703  {
7704  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditRequest2_state);
7705  }
7706  else
7707  {
7708  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditRequest2_state, bank_BankCreditLoanWriteOffs_state);
7709  }
7710 
7711 
7712  current_xmachine_bank = NULL;
7713 
7714  current_xmachine_bank_holder = temp_xmachine_bank_holder;
7715  }
7716  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_process_loan_requests_2\n");
7717 
7718  if(FLAME_loan_acknowledge_2_message_board_write == 1)
7719  {
7720 
7721  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_acknowledge_2)\n");
7722  rc = MB_SyncStart(b_loan_acknowledge_2);
7723  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_acknowledge_2)\n");
7724  #ifdef ERRCHECK
7725  if (rc != MB_SUCCESS)
7726  {
7727  fprintf(stderr, "ERROR: Could not start sync of 'loan_acknowledge_2' board\n");
7728  switch(rc) {
7729  case MB_ERR_INVALID:
7730  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is invalid\n");
7731  break;
7732  case MB_ERR_LOCKED:
7733  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is locked\n");
7734  break;
7735  case MB_ERR_MEMALLOC:
7736  fprintf(stderr, "\t reason: out of memory\n");
7737  break;
7738  case MB_ERR_INTERNAL:
7739  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7740  break;
7741  default:
7742  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
7743  break;
7744  }
7745 
7746 
7747  exit(rc);
7748  }
7749  #endif
7750  }
7751 
7752 
7753 
7754  /* If mb is not read then leave sync complete until last possible moment */
7755  if(FLAME_interest_rate_message_board_read == 1)
7756  {
7757  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_interest_rate)\n");
7758  rc = MB_SyncComplete(b_interest_rate);
7759  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_interest_rate)\n");
7760  #ifdef ERRCHECK
7761  if (rc != MB_SUCCESS)
7762  {
7763  fprintf(stderr, "ERROR: Could not complete sync of 'interest_rate' board\n");
7764  switch(rc) {
7765  case MB_ERR_INVALID:
7766  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
7767  break;
7768  case MB_ERR_MEMALLOC:
7769  fprintf(stderr, "\t reason: out of memory\n");
7770  break;
7771  case MB_ERR_INTERNAL:
7772  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7773  break;
7774  default:
7775  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
7776  break;
7777  }
7778 
7779 
7780  exit(rc);
7781  }
7782  #endif
7783 
7784 
7785 
7786  }
7787 
7788  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start reagency_housing_check_interest_rate\n");
7789  current_xmachine_reagency_holder = reagency_REAgencyHousingMarket_state->agents;
7790  while(current_xmachine_reagency_holder)
7791  {
7792  temp_xmachine_reagency_holder = current_xmachine_reagency_holder->next;
7793  current_xmachine_reagency = current_xmachine_reagency_holder->agent;
7794  current_xmachine_reagency_next_state = reagency_REAgencyHousingProcess_state;
7795  /* For backwards compatibility set current_xmachine */
7796  current_xmachine->xmachine_firm = NULL;
7797  current_xmachine->xmachine_household = NULL;
7798  current_xmachine->xmachine_equityfund = NULL;
7799  current_xmachine->xmachine_bank = NULL;
7800  current_xmachine->xmachine_government = NULL;
7801  current_xmachine->xmachine_centralbank = NULL;
7802  current_xmachine->xmachine_jpoffice = NULL;
7803  current_xmachine->xmachine_mall = NULL;
7804  current_xmachine->xmachine_reagency = NULL;
7805  current_xmachine->xmachine_reagency = current_xmachine_reagency;
7806 
7807  if(FLAME_condition_reagency_reagency_housing_check_interest_rate_REAgencyHousingMarket_REAgencyHousingProcess(current_xmachine_reagency)==1)
7808  {
7809 
7810 
7811 
7812 
7813  rc = MB_Iterator_Create(b_interest_rate, &i_interest_rate);
7814 
7815 
7816  #ifdef ERRCHECK
7817  if (rc != MB_SUCCESS)
7818  {
7819  fprintf(stderr, "ERROR: Could not create Iterator for 'interest_rate'\n");
7820  switch(rc) {
7821  case MB_ERR_INVALID:
7822  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
7823  break;
7824  case MB_ERR_LOCKED:
7825  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
7826  break;
7827  case MB_ERR_MEMALLOC:
7828  fprintf(stderr, "\t reason: out of memory\n");
7829  break;
7830  case MB_ERR_INTERNAL:
7831  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7832  break;
7833  default:
7834 
7835 
7836  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
7837 
7838  break;
7839  }
7840 
7841 
7842  exit(rc);
7843  }
7844  #endif
7845 
7846 
7847 
7848  i = reagency_housing_check_interest_rate();
7849 
7850 
7851  rc = MB_Iterator_Delete(&i_interest_rate);
7852  #ifdef ERRCHECK
7853  if (rc != MB_SUCCESS)
7854  {
7855  fprintf(stderr, "ERROR: Could not delete 'interest_rate' iterator\n");
7856  switch(rc) {
7857  case MB_ERR_INVALID:
7858  fprintf(stderr, "\t reason: 'interest_rate' iterator is invalid\n");
7859  break;
7860  case MB_ERR_INTERNAL:
7861  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7862  break;
7863  default:
7864  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
7865  break;
7866  }
7867 
7868 
7869  exit(rc);
7870  }
7871  #endif
7872 
7873 
7874  if(i == 1)
7875  {
7876  free_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingMarket_state);
7877  }
7878  else
7879  {
7880  transition_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingMarket_state, reagency_REAgencyHousingProcess_state);
7881  }
7882  }
7883 
7884  current_xmachine_reagency = NULL;
7885 
7886  current_xmachine_reagency_holder = temp_xmachine_reagency_holder;
7887  }
7888  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish reagency_housing_check_interest_rate\n");
7889 
7890 
7891 /* End of layer number 8 */
7892 
7893 /* Clear message boards that have finished being used
7894  * and sync complete if doing late sync complete */
7895 
7896 if(FLAME_loan_request_2_message_board_read == 0)
7897 {
7898  /*printf("%d> loan_request_2 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
7899 
7900  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_request_2)\n");
7901  rc = MB_SyncComplete(b_loan_request_2);
7902  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_request_2)\n");
7903  #ifdef ERRCHECK
7904  if (rc != MB_SUCCESS)
7905  {
7906  fprintf(stderr, "ERROR: Could not complete sync of 'loan_request_2' board\n");
7907  switch(rc) {
7908  case MB_ERR_INVALID:
7909  fprintf(stderr, "\t reason: 'loan_request_2' board is invalid\n");
7910  break;
7911  case MB_ERR_MEMALLOC:
7912  fprintf(stderr, "\t reason: out of memory\n");
7913  break;
7914  case MB_ERR_INTERNAL:
7915  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7916  break;
7917  default:
7918  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
7919  break;
7920  }
7921 
7922 
7923  exit(rc);
7924  }
7925  #endif
7926 }
7927 
7928  /* Delete any search trees */
7929 
7930  rc = MB_Clear(b_loan_request_2);
7931  #ifdef ERRCHECK
7932  if (rc != MB_SUCCESS)
7933  {
7934  fprintf(stderr, "ERROR: Could not clear 'loan_request_2' board\n");
7935  switch(rc) {
7936  case MB_ERR_INVALID:
7937  fprintf(stderr, "\t reason: 'loan_request_2' board is invalid\n");
7938  break;
7939  case MB_ERR_LOCKED:
7940  fprintf(stderr, "\t reason: 'loan_request_2' board is locked\n");
7941  break;
7942  case MB_ERR_INTERNAL:
7943  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7944  break;
7945  default:
7946  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
7947  break;
7948 
7949  }
7950 
7951 
7952  exit(rc);
7953  }
7954  #endif
7955 
7956 
7957  /* If mb is not read then leave sync complete until last possible moment */
7958  if(FLAME_loan_acknowledge_2_message_board_read == 1)
7959  {
7960  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_acknowledge_2)\n");
7961  rc = MB_SyncComplete(b_loan_acknowledge_2);
7962  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_acknowledge_2)\n");
7963  #ifdef ERRCHECK
7964  if (rc != MB_SUCCESS)
7965  {
7966  fprintf(stderr, "ERROR: Could not complete sync of 'loan_acknowledge_2' board\n");
7967  switch(rc) {
7968  case MB_ERR_INVALID:
7969  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is invalid\n");
7970  break;
7971  case MB_ERR_MEMALLOC:
7972  fprintf(stderr, "\t reason: out of memory\n");
7973  break;
7974  case MB_ERR_INTERNAL:
7975  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
7976  break;
7977  default:
7978  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
7979  break;
7980  }
7981 
7982 
7983  exit(rc);
7984  }
7985  #endif
7986 
7987 
7988 
7989  }
7990 
7991  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_borrow_loans_2\n");
7992  current_xmachine_firm_holder = firm_FirmCreditLoanBorrow2_state->agents;
7993  while(current_xmachine_firm_holder)
7994  {
7995  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
7996  current_xmachine_firm = current_xmachine_firm_holder->agent;
7997  current_xmachine_firm_next_state = firm_FirmCreditIlliquidityStatus_state;
7998  /* For backwards compatibility set current_xmachine */
7999  current_xmachine->xmachine_firm = NULL;
8000  current_xmachine->xmachine_household = NULL;
8001  current_xmachine->xmachine_equityfund = NULL;
8002  current_xmachine->xmachine_bank = NULL;
8003  current_xmachine->xmachine_government = NULL;
8004  current_xmachine->xmachine_centralbank = NULL;
8005  current_xmachine->xmachine_jpoffice = NULL;
8006  current_xmachine->xmachine_mall = NULL;
8007  current_xmachine->xmachine_reagency = NULL;
8008  current_xmachine->xmachine_firm = current_xmachine_firm;
8009 
8010  if(FLAME_condition_firm_firm_credit_borrow_loans_2_FirmCreditLoanBorrow2_FirmCreditIlliquidityStatus(current_xmachine_firm)==1)
8011  {
8012 
8013 
8014 
8015 
8016 
8017 
8018  rc = MB_Iterator_CreateFiltered(b_loan_acknowledge_2, &i_loan_acknowledge_2, &FLAME_filter_firm_firm_credit_borrow_loans_2_FirmCreditLoanBorrow2_FirmCreditIlliquidityStatus_loan_acknowledge_2, current_xmachine_firm);
8019 
8020 
8021 
8022  #ifdef ERRCHECK
8023  if (rc != MB_SUCCESS)
8024  {
8025  fprintf(stderr, "ERROR: Could not create Iterator for 'loan_acknowledge_2'\n");
8026  switch(rc) {
8027  case MB_ERR_INVALID:
8028  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is invalid\n");
8029  break;
8030  case MB_ERR_LOCKED:
8031  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is locked\n");
8032  break;
8033  case MB_ERR_MEMALLOC:
8034  fprintf(stderr, "\t reason: out of memory\n");
8035  break;
8036  case MB_ERR_INTERNAL:
8037  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8038  break;
8039  default:
8040 
8041  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
8042 
8043 
8044  break;
8045  }
8046 
8047 
8048  exit(rc);
8049  }
8050  #endif
8051 
8052 
8053 
8054  i = firm_credit_borrow_loans_2();
8055 
8056 
8057  rc = MB_Iterator_Delete(&i_loan_acknowledge_2);
8058  #ifdef ERRCHECK
8059  if (rc != MB_SUCCESS)
8060  {
8061  fprintf(stderr, "ERROR: Could not delete 'loan_acknowledge_2' iterator\n");
8062  switch(rc) {
8063  case MB_ERR_INVALID:
8064  fprintf(stderr, "\t reason: 'loan_acknowledge_2' iterator is invalid\n");
8065  break;
8066  case MB_ERR_INTERNAL:
8067  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8068  break;
8069  default:
8070  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
8071  break;
8072  }
8073 
8074 
8075  exit(rc);
8076  }
8077  #endif
8078 
8079 
8080  if(i == 1)
8081  {
8082  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLoanBorrow2_state);
8083  }
8084  else
8085  {
8086  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLoanBorrow2_state, firm_FirmCreditIlliquidityStatus_state);
8087  }
8088  }
8089 
8090  current_xmachine_firm = NULL;
8091 
8092  current_xmachine_firm_holder = temp_xmachine_firm_holder;
8093  }
8094  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_borrow_loans_2\n");
8095 
8096 
8097 /* End of layer number 9 */
8098 
8099 /* Clear message boards that have finished being used
8100  * and sync complete if doing late sync complete */
8101 
8102 if(FLAME_loan_acknowledge_2_message_board_read == 0)
8103 {
8104  /*printf("%d> loan_acknowledge_2 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
8105 
8106  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_acknowledge_2)\n");
8107  rc = MB_SyncComplete(b_loan_acknowledge_2);
8108  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_acknowledge_2)\n");
8109  #ifdef ERRCHECK
8110  if (rc != MB_SUCCESS)
8111  {
8112  fprintf(stderr, "ERROR: Could not complete sync of 'loan_acknowledge_2' board\n");
8113  switch(rc) {
8114  case MB_ERR_INVALID:
8115  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is invalid\n");
8116  break;
8117  case MB_ERR_MEMALLOC:
8118  fprintf(stderr, "\t reason: out of memory\n");
8119  break;
8120  case MB_ERR_INTERNAL:
8121  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8122  break;
8123  default:
8124  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
8125  break;
8126  }
8127 
8128 
8129  exit(rc);
8130  }
8131  #endif
8132 }
8133 
8134  /* Delete any search trees */
8135 
8136  rc = MB_Clear(b_loan_acknowledge_2);
8137  #ifdef ERRCHECK
8138  if (rc != MB_SUCCESS)
8139  {
8140  fprintf(stderr, "ERROR: Could not clear 'loan_acknowledge_2' board\n");
8141  switch(rc) {
8142  case MB_ERR_INVALID:
8143  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is invalid\n");
8144  break;
8145  case MB_ERR_LOCKED:
8146  fprintf(stderr, "\t reason: 'loan_acknowledge_2' board is locked\n");
8147  break;
8148  case MB_ERR_INTERNAL:
8149  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8150  break;
8151  default:
8152  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
8153  break;
8154 
8155  }
8156 
8157 
8158  exit(rc);
8159  }
8160  #endif
8161 
8162  /* DEBUG: States with branching functions */
8163  current_xmachine_firm_holder = firm_FirmCreditIlliquidityStatus_state->agents;
8164  while(current_xmachine_firm_holder)
8165  {
8166  FLAME_debug_count = 0;
8167  /* Function: firm_credit_request_equityfund_investment */
8168  if(FLAME_condition_firm_firm_credit_request_equityfund_investment_FirmCreditIlliquidityStatus_FirmCreditLiquidityRecheck(current_xmachine_firm_holder->agent)==1)
8169  { FLAME_debug_count++; }
8170  /* Function: idle */
8171  if(FLAME_condition_firm_idle_FirmCreditIlliquidityStatus_FirmCreditPayments(current_xmachine_firm_holder->agent)==1)
8172  { FLAME_debug_count++; }
8173  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
8174  if(FLAME_debug_count != 1)
8175  {
8176  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmCreditIlliquidityStatus'\n");
8177  if(FLAME_debug_count > 1)
8178  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
8179  if(FLAME_debug_count == 0)
8180  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
8181  }
8182 
8183  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
8184  }
8185 
8186  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_request_equityfund_investment\n");
8187  current_xmachine_firm_holder = firm_FirmCreditIlliquidityStatus_state->agents;
8188  while(current_xmachine_firm_holder)
8189  {
8190  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
8191  current_xmachine_firm = current_xmachine_firm_holder->agent;
8192  current_xmachine_firm_next_state = firm_FirmCreditLiquidityRecheck_state;
8193  /* For backwards compatibility set current_xmachine */
8194  current_xmachine->xmachine_firm = NULL;
8195  current_xmachine->xmachine_household = NULL;
8196  current_xmachine->xmachine_equityfund = NULL;
8197  current_xmachine->xmachine_bank = NULL;
8198  current_xmachine->xmachine_government = NULL;
8199  current_xmachine->xmachine_centralbank = NULL;
8200  current_xmachine->xmachine_jpoffice = NULL;
8201  current_xmachine->xmachine_mall = NULL;
8202  current_xmachine->xmachine_reagency = NULL;
8203  current_xmachine->xmachine_firm = current_xmachine_firm;
8204 
8205  if(FLAME_condition_firm_firm_credit_request_equityfund_investment_FirmCreditIlliquidityStatus_FirmCreditLiquidityRecheck(current_xmachine_firm)==1)
8206  {
8207 
8208 
8209 
8210  i = firm_credit_request_equityfund_investment();
8211 
8212 
8213 
8214  if(i == 1)
8215  {
8216  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditIlliquidityStatus_state);
8217  }
8218  else
8219  {
8220  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditIlliquidityStatus_state, firm_FirmCreditLiquidityRecheck_state);
8221  }
8222  }
8223 
8224  current_xmachine_firm = NULL;
8225 
8226  current_xmachine_firm_holder = temp_xmachine_firm_holder;
8227  }
8228  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_request_equityfund_investment\n");
8229 
8230  if(FLAME_fund_request_message_board_write == 1)
8231  {
8232 
8233  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_fund_request)\n");
8234  rc = MB_SyncStart(b_fund_request);
8235  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_fund_request)\n");
8236  #ifdef ERRCHECK
8237  if (rc != MB_SUCCESS)
8238  {
8239  fprintf(stderr, "ERROR: Could not start sync of 'fund_request' board\n");
8240  switch(rc) {
8241  case MB_ERR_INVALID:
8242  fprintf(stderr, "\t reason: 'fund_request' board is invalid\n");
8243  break;
8244  case MB_ERR_LOCKED:
8245  fprintf(stderr, "\t reason: 'fund_request' board is locked\n");
8246  break;
8247  case MB_ERR_MEMALLOC:
8248  fprintf(stderr, "\t reason: out of memory\n");
8249  break;
8250  case MB_ERR_INTERNAL:
8251  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8252  break;
8253  default:
8254  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
8255  break;
8256  }
8257 
8258 
8259  exit(rc);
8260  }
8261  #endif
8262  }
8263 
8264 
8265 
8266  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
8267  current_xmachine_firm_holder = firm_FirmCreditIlliquidityStatus_state->agents;
8268  while(current_xmachine_firm_holder)
8269  {
8270  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
8271  current_xmachine_firm = current_xmachine_firm_holder->agent;
8272  current_xmachine_firm_next_state = firm_FirmCreditPayments_state;
8273  /* For backwards compatibility set current_xmachine */
8274  current_xmachine->xmachine_firm = NULL;
8275  current_xmachine->xmachine_household = NULL;
8276  current_xmachine->xmachine_equityfund = NULL;
8277  current_xmachine->xmachine_bank = NULL;
8278  current_xmachine->xmachine_government = NULL;
8279  current_xmachine->xmachine_centralbank = NULL;
8280  current_xmachine->xmachine_jpoffice = NULL;
8281  current_xmachine->xmachine_mall = NULL;
8282  current_xmachine->xmachine_reagency = NULL;
8283  current_xmachine->xmachine_firm = current_xmachine_firm;
8284 
8285  if(FLAME_condition_firm_idle_FirmCreditIlliquidityStatus_FirmCreditPayments(current_xmachine_firm)==1)
8286  {
8287 
8288 
8289 
8290  i = idle();
8291 
8292 
8293 
8294  if(i == 1)
8295  {
8296  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditIlliquidityStatus_state);
8297  }
8298  else
8299  {
8300  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditIlliquidityStatus_state, firm_FirmCreditPayments_state);
8301  }
8302  }
8303 
8304  current_xmachine_firm = NULL;
8305 
8306  current_xmachine_firm_holder = temp_xmachine_firm_holder;
8307  }
8308  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
8309 
8310 
8311 /* End of layer number 10 */
8312 
8313 /* Clear message boards that have finished being used
8314  * and sync complete if doing late sync complete */
8315 
8316  /* DEBUG: States with branching functions */
8317  current_xmachine_firm_holder = firm_FirmCreditLiquidityRecheck_state->agents;
8318  while(current_xmachine_firm_holder)
8319  {
8320  FLAME_debug_count = 0;
8321  /* Function: firm_credit_check_equityfund_investment */
8322  if(FLAME_condition_firm_firm_credit_check_equityfund_investment_FirmCreditLiquidityRecheck_FirmCreditBankruptcy(current_xmachine_firm_holder->agent)==1)
8323  { FLAME_debug_count++; }
8324  /* Function: idle */
8325  if(FLAME_condition_firm_idle_FirmCreditLiquidityRecheck_FirmCreditPayments(current_xmachine_firm_holder->agent)==1)
8326  { FLAME_debug_count++; }
8327  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
8328  if(FLAME_debug_count != 1)
8329  {
8330  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmCreditLiquidityRecheck'\n");
8331  if(FLAME_debug_count > 1)
8332  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
8333  if(FLAME_debug_count == 0)
8334  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
8335  }
8336 
8337  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
8338  }
8339 
8340  /* If mb is not read then leave sync complete until last possible moment */
8341  if(FLAME_fund_request_message_board_read == 1)
8342  {
8343  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_fund_request)\n");
8344  rc = MB_SyncComplete(b_fund_request);
8345  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_fund_request)\n");
8346  #ifdef ERRCHECK
8347  if (rc != MB_SUCCESS)
8348  {
8349  fprintf(stderr, "ERROR: Could not complete sync of 'fund_request' board\n");
8350  switch(rc) {
8351  case MB_ERR_INVALID:
8352  fprintf(stderr, "\t reason: 'fund_request' board is invalid\n");
8353  break;
8354  case MB_ERR_MEMALLOC:
8355  fprintf(stderr, "\t reason: out of memory\n");
8356  break;
8357  case MB_ERR_INTERNAL:
8358  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8359  break;
8360  default:
8361  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
8362  break;
8363  }
8364 
8365 
8366  exit(rc);
8367  }
8368  #endif
8369 
8370 
8371 
8372  }
8373 
8374  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_credit_invest_illiquids\n");
8375  current_xmachine_equityfund_holder = equityfund_EquityFundStart_state->agents;
8376  while(current_xmachine_equityfund_holder)
8377  {
8378  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
8379  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
8380  current_xmachine_equityfund_next_state = equityfund_EFCreditDistributeShares_state;
8381  /* For backwards compatibility set current_xmachine */
8382  current_xmachine->xmachine_firm = NULL;
8383  current_xmachine->xmachine_household = NULL;
8384  current_xmachine->xmachine_equityfund = NULL;
8385  current_xmachine->xmachine_bank = NULL;
8386  current_xmachine->xmachine_government = NULL;
8387  current_xmachine->xmachine_centralbank = NULL;
8388  current_xmachine->xmachine_jpoffice = NULL;
8389  current_xmachine->xmachine_mall = NULL;
8390  current_xmachine->xmachine_reagency = NULL;
8391  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
8392 
8393  if(FLAME_condition_equityfund_equityfund_credit_invest_illiquids_EquityFundStart_EFCreditDistributeShares(current_xmachine_equityfund)==1)
8394  {
8395 
8396 
8397 
8398 
8399  rc = MB_Iterator_Create(b_fund_request, &i_fund_request);
8400 
8401 
8402  #ifdef ERRCHECK
8403  if (rc != MB_SUCCESS)
8404  {
8405  fprintf(stderr, "ERROR: Could not create Iterator for 'fund_request'\n");
8406  switch(rc) {
8407  case MB_ERR_INVALID:
8408  fprintf(stderr, "\t reason: 'fund_request' board is invalid\n");
8409  break;
8410  case MB_ERR_LOCKED:
8411  fprintf(stderr, "\t reason: 'fund_request' board is locked\n");
8412  break;
8413  case MB_ERR_MEMALLOC:
8414  fprintf(stderr, "\t reason: out of memory\n");
8415  break;
8416  case MB_ERR_INTERNAL:
8417  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8418  break;
8419  default:
8420 
8421 
8422  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
8423 
8424  break;
8425  }
8426 
8427 
8428  exit(rc);
8429  }
8430  #endif
8431  MB_Iterator_Randomise(i_fund_request);
8432 
8433 
8434  i = equityfund_credit_invest_illiquids();
8435 
8436 
8437  rc = MB_Iterator_Delete(&i_fund_request);
8438  #ifdef ERRCHECK
8439  if (rc != MB_SUCCESS)
8440  {
8441  fprintf(stderr, "ERROR: Could not delete 'fund_request' iterator\n");
8442  switch(rc) {
8443  case MB_ERR_INVALID:
8444  fprintf(stderr, "\t reason: 'fund_request' iterator is invalid\n");
8445  break;
8446  case MB_ERR_INTERNAL:
8447  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8448  break;
8449  default:
8450  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
8451  break;
8452  }
8453 
8454 
8455  exit(rc);
8456  }
8457  #endif
8458 
8459 
8460  if(i == 1)
8461  {
8462  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EquityFundStart_state);
8463  }
8464  else
8465  {
8466  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EquityFundStart_state, equityfund_EFCreditDistributeShares_state);
8467  }
8468  }
8469 
8470  current_xmachine_equityfund = NULL;
8471 
8472  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
8473  }
8474  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_credit_invest_illiquids\n");
8475 
8476  if(FLAME_fund_request_ack_message_board_write == 1)
8477  {
8478 
8479  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_fund_request_ack)\n");
8480  rc = MB_SyncStart(b_fund_request_ack);
8481  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_fund_request_ack)\n");
8482  #ifdef ERRCHECK
8483  if (rc != MB_SUCCESS)
8484  {
8485  fprintf(stderr, "ERROR: Could not start sync of 'fund_request_ack' board\n");
8486  switch(rc) {
8487  case MB_ERR_INVALID:
8488  fprintf(stderr, "\t reason: 'fund_request_ack' board is invalid\n");
8489  break;
8490  case MB_ERR_LOCKED:
8491  fprintf(stderr, "\t reason: 'fund_request_ack' board is locked\n");
8492  break;
8493  case MB_ERR_MEMALLOC:
8494  fprintf(stderr, "\t reason: out of memory\n");
8495  break;
8496  case MB_ERR_INTERNAL:
8497  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8498  break;
8499  default:
8500  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
8501  break;
8502  }
8503 
8504 
8505  exit(rc);
8506  }
8507  #endif
8508  }
8509 
8510 
8511 
8512  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
8513  current_xmachine_firm_holder = firm_FirmCreditLiquidityRecheck_state->agents;
8514  while(current_xmachine_firm_holder)
8515  {
8516  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
8517  current_xmachine_firm = current_xmachine_firm_holder->agent;
8518  current_xmachine_firm_next_state = firm_FirmCreditPayments_state;
8519  /* For backwards compatibility set current_xmachine */
8520  current_xmachine->xmachine_firm = NULL;
8521  current_xmachine->xmachine_household = NULL;
8522  current_xmachine->xmachine_equityfund = NULL;
8523  current_xmachine->xmachine_bank = NULL;
8524  current_xmachine->xmachine_government = NULL;
8525  current_xmachine->xmachine_centralbank = NULL;
8526  current_xmachine->xmachine_jpoffice = NULL;
8527  current_xmachine->xmachine_mall = NULL;
8528  current_xmachine->xmachine_reagency = NULL;
8529  current_xmachine->xmachine_firm = current_xmachine_firm;
8530 
8531  if(FLAME_condition_firm_idle_FirmCreditLiquidityRecheck_FirmCreditPayments(current_xmachine_firm)==1)
8532  {
8533 
8534 
8535 
8536  i = idle();
8537 
8538 
8539 
8540  if(i == 1)
8541  {
8542  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLiquidityRecheck_state);
8543  }
8544  else
8545  {
8546  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLiquidityRecheck_state, firm_FirmCreditPayments_state);
8547  }
8548  }
8549 
8550  current_xmachine_firm = NULL;
8551 
8552  current_xmachine_firm_holder = temp_xmachine_firm_holder;
8553  }
8554  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
8555 
8556 
8557 /* End of layer number 11 */
8558 
8559 /* Clear message boards that have finished being used
8560  * and sync complete if doing late sync complete */
8561 
8562 if(FLAME_fund_request_message_board_read == 0)
8563 {
8564  /*printf("%d> fund_request message board sync complete late as no agents reading any messages of this type\n", node_number);*/
8565 
8566  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_fund_request)\n");
8567  rc = MB_SyncComplete(b_fund_request);
8568  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_fund_request)\n");
8569  #ifdef ERRCHECK
8570  if (rc != MB_SUCCESS)
8571  {
8572  fprintf(stderr, "ERROR: Could not complete sync of 'fund_request' board\n");
8573  switch(rc) {
8574  case MB_ERR_INVALID:
8575  fprintf(stderr, "\t reason: 'fund_request' board is invalid\n");
8576  break;
8577  case MB_ERR_MEMALLOC:
8578  fprintf(stderr, "\t reason: out of memory\n");
8579  break;
8580  case MB_ERR_INTERNAL:
8581  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8582  break;
8583  default:
8584  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
8585  break;
8586  }
8587 
8588 
8589  exit(rc);
8590  }
8591  #endif
8592 }
8593 
8594  /* Delete any search trees */
8595 
8596  rc = MB_Clear(b_fund_request);
8597  #ifdef ERRCHECK
8598  if (rc != MB_SUCCESS)
8599  {
8600  fprintf(stderr, "ERROR: Could not clear 'fund_request' board\n");
8601  switch(rc) {
8602  case MB_ERR_INVALID:
8603  fprintf(stderr, "\t reason: 'fund_request' board is invalid\n");
8604  break;
8605  case MB_ERR_LOCKED:
8606  fprintf(stderr, "\t reason: 'fund_request' board is locked\n");
8607  break;
8608  case MB_ERR_INTERNAL:
8609  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8610  break;
8611  default:
8612  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
8613  break;
8614 
8615  }
8616 
8617 
8618  exit(rc);
8619  }
8620  #endif
8621 
8622 
8623  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_credit_distribute_shares\n");
8624  current_xmachine_equityfund_holder = equityfund_EFCreditDistributeShares_state->agents;
8625  while(current_xmachine_equityfund_holder)
8626  {
8627  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
8628  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
8629  current_xmachine_equityfund_next_state = equityfund_EFCreditShareCollectionBanks_state;
8630  /* For backwards compatibility set current_xmachine */
8631  current_xmachine->xmachine_firm = NULL;
8632  current_xmachine->xmachine_household = NULL;
8633  current_xmachine->xmachine_equityfund = NULL;
8634  current_xmachine->xmachine_bank = NULL;
8635  current_xmachine->xmachine_government = NULL;
8636  current_xmachine->xmachine_centralbank = NULL;
8637  current_xmachine->xmachine_jpoffice = NULL;
8638  current_xmachine->xmachine_mall = NULL;
8639  current_xmachine->xmachine_reagency = NULL;
8640  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
8641 
8642 
8643 
8644 
8645 
8646  i = equityfund_credit_distribute_shares();
8647 
8648 
8649 
8650  if(i == 1)
8651  {
8652  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditDistributeShares_state);
8653  }
8654  else
8655  {
8656  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditDistributeShares_state, equityfund_EFCreditShareCollectionBanks_state);
8657  }
8658 
8659 
8660  current_xmachine_equityfund = NULL;
8661 
8662  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
8663  }
8664  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_credit_distribute_shares\n");
8665 
8666  if(FLAME_capital_tax_message_board_write == 1)
8667  {
8668 
8669  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_capital_tax)\n");
8670  rc = MB_SyncStart(b_capital_tax);
8671  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_capital_tax)\n");
8672  #ifdef ERRCHECK
8673  if (rc != MB_SUCCESS)
8674  {
8675  fprintf(stderr, "ERROR: Could not start sync of 'capital_tax' board\n");
8676  switch(rc) {
8677  case MB_ERR_INVALID:
8678  fprintf(stderr, "\t reason: 'capital_tax' board is invalid\n");
8679  break;
8680  case MB_ERR_LOCKED:
8681  fprintf(stderr, "\t reason: 'capital_tax' board is locked\n");
8682  break;
8683  case MB_ERR_MEMALLOC:
8684  fprintf(stderr, "\t reason: out of memory\n");
8685  break;
8686  case MB_ERR_INTERNAL:
8687  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8688  break;
8689  default:
8690  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
8691  break;
8692  }
8693 
8694 
8695  exit(rc);
8696  }
8697  #endif
8698  }
8699 
8700 
8701  if(FLAME_household_share_message_board_write == 1)
8702  {
8703 
8704  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_household_share)\n");
8705  rc = MB_SyncStart(b_household_share);
8706  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_household_share)\n");
8707  #ifdef ERRCHECK
8708  if (rc != MB_SUCCESS)
8709  {
8710  fprintf(stderr, "ERROR: Could not start sync of 'household_share' board\n");
8711  switch(rc) {
8712  case MB_ERR_INVALID:
8713  fprintf(stderr, "\t reason: 'household_share' board is invalid\n");
8714  break;
8715  case MB_ERR_LOCKED:
8716  fprintf(stderr, "\t reason: 'household_share' board is locked\n");
8717  break;
8718  case MB_ERR_MEMALLOC:
8719  fprintf(stderr, "\t reason: out of memory\n");
8720  break;
8721  case MB_ERR_INTERNAL:
8722  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8723  break;
8724  default:
8725  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
8726  break;
8727  }
8728 
8729 
8730  exit(rc);
8731  }
8732  #endif
8733  }
8734 
8735 
8736 
8737  /* If mb is not read then leave sync complete until last possible moment */
8738  if(FLAME_fund_request_ack_message_board_read == 1)
8739  {
8740  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_fund_request_ack)\n");
8741  rc = MB_SyncComplete(b_fund_request_ack);
8742  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_fund_request_ack)\n");
8743  #ifdef ERRCHECK
8744  if (rc != MB_SUCCESS)
8745  {
8746  fprintf(stderr, "ERROR: Could not complete sync of 'fund_request_ack' board\n");
8747  switch(rc) {
8748  case MB_ERR_INVALID:
8749  fprintf(stderr, "\t reason: 'fund_request_ack' board is invalid\n");
8750  break;
8751  case MB_ERR_MEMALLOC:
8752  fprintf(stderr, "\t reason: out of memory\n");
8753  break;
8754  case MB_ERR_INTERNAL:
8755  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8756  break;
8757  default:
8758  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
8759  break;
8760  }
8761 
8762 
8763  exit(rc);
8764  }
8765  #endif
8766 
8767 
8768 
8769  }
8770 
8771  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_check_equityfund_investment\n");
8772  current_xmachine_firm_holder = firm_FirmCreditLiquidityRecheck_state->agents;
8773  while(current_xmachine_firm_holder)
8774  {
8775  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
8776  current_xmachine_firm = current_xmachine_firm_holder->agent;
8777  current_xmachine_firm_next_state = firm_FirmCreditBankruptcy_state;
8778  /* For backwards compatibility set current_xmachine */
8779  current_xmachine->xmachine_firm = NULL;
8780  current_xmachine->xmachine_household = NULL;
8781  current_xmachine->xmachine_equityfund = NULL;
8782  current_xmachine->xmachine_bank = NULL;
8783  current_xmachine->xmachine_government = NULL;
8784  current_xmachine->xmachine_centralbank = NULL;
8785  current_xmachine->xmachine_jpoffice = NULL;
8786  current_xmachine->xmachine_mall = NULL;
8787  current_xmachine->xmachine_reagency = NULL;
8788  current_xmachine->xmachine_firm = current_xmachine_firm;
8789 
8790  if(FLAME_condition_firm_firm_credit_check_equityfund_investment_FirmCreditLiquidityRecheck_FirmCreditBankruptcy(current_xmachine_firm)==1)
8791  {
8792 
8793 
8794 
8795 
8796 
8797 
8798  rc = MB_Iterator_CreateFiltered(b_fund_request_ack, &i_fund_request_ack, &FLAME_filter_firm_firm_credit_check_equityfund_investment_FirmCreditLiquidityRecheck_FirmCreditBankruptcy_fund_request_ack, current_xmachine_firm);
8799 
8800 
8801 
8802  #ifdef ERRCHECK
8803  if (rc != MB_SUCCESS)
8804  {
8805  fprintf(stderr, "ERROR: Could not create Iterator for 'fund_request_ack'\n");
8806  switch(rc) {
8807  case MB_ERR_INVALID:
8808  fprintf(stderr, "\t reason: 'fund_request_ack' board is invalid\n");
8809  break;
8810  case MB_ERR_LOCKED:
8811  fprintf(stderr, "\t reason: 'fund_request_ack' board is locked\n");
8812  break;
8813  case MB_ERR_MEMALLOC:
8814  fprintf(stderr, "\t reason: out of memory\n");
8815  break;
8816  case MB_ERR_INTERNAL:
8817  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8818  break;
8819  default:
8820 
8821  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
8822 
8823 
8824  break;
8825  }
8826 
8827 
8828  exit(rc);
8829  }
8830  #endif
8831 
8832 
8833 
8834  i = firm_credit_check_equityfund_investment();
8835 
8836 
8837  rc = MB_Iterator_Delete(&i_fund_request_ack);
8838  #ifdef ERRCHECK
8839  if (rc != MB_SUCCESS)
8840  {
8841  fprintf(stderr, "ERROR: Could not delete 'fund_request_ack' iterator\n");
8842  switch(rc) {
8843  case MB_ERR_INVALID:
8844  fprintf(stderr, "\t reason: 'fund_request_ack' iterator is invalid\n");
8845  break;
8846  case MB_ERR_INTERNAL:
8847  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8848  break;
8849  default:
8850  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
8851  break;
8852  }
8853 
8854 
8855  exit(rc);
8856  }
8857  #endif
8858 
8859 
8860  if(i == 1)
8861  {
8862  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLiquidityRecheck_state);
8863  }
8864  else
8865  {
8866  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditLiquidityRecheck_state, firm_FirmCreditBankruptcy_state);
8867  }
8868  }
8869 
8870  current_xmachine_firm = NULL;
8871 
8872  current_xmachine_firm_holder = temp_xmachine_firm_holder;
8873  }
8874  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_check_equityfund_investment\n");
8875 
8876 
8877 /* End of layer number 12 */
8878 
8879 /* Clear message boards that have finished being used
8880  * and sync complete if doing late sync complete */
8881 
8882 if(FLAME_fund_request_ack_message_board_read == 0)
8883 {
8884  /*printf("%d> fund_request_ack message board sync complete late as no agents reading any messages of this type\n", node_number);*/
8885 
8886  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_fund_request_ack)\n");
8887  rc = MB_SyncComplete(b_fund_request_ack);
8888  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_fund_request_ack)\n");
8889  #ifdef ERRCHECK
8890  if (rc != MB_SUCCESS)
8891  {
8892  fprintf(stderr, "ERROR: Could not complete sync of 'fund_request_ack' board\n");
8893  switch(rc) {
8894  case MB_ERR_INVALID:
8895  fprintf(stderr, "\t reason: 'fund_request_ack' board is invalid\n");
8896  break;
8897  case MB_ERR_MEMALLOC:
8898  fprintf(stderr, "\t reason: out of memory\n");
8899  break;
8900  case MB_ERR_INTERNAL:
8901  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8902  break;
8903  default:
8904  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
8905  break;
8906  }
8907 
8908 
8909  exit(rc);
8910  }
8911  #endif
8912 }
8913 
8914  /* Delete any search trees */
8915 
8916  rc = MB_Clear(b_fund_request_ack);
8917  #ifdef ERRCHECK
8918  if (rc != MB_SUCCESS)
8919  {
8920  fprintf(stderr, "ERROR: Could not clear 'fund_request_ack' board\n");
8921  switch(rc) {
8922  case MB_ERR_INVALID:
8923  fprintf(stderr, "\t reason: 'fund_request_ack' board is invalid\n");
8924  break;
8925  case MB_ERR_LOCKED:
8926  fprintf(stderr, "\t reason: 'fund_request_ack' board is locked\n");
8927  break;
8928  case MB_ERR_INTERNAL:
8929  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
8930  break;
8931  default:
8932  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
8933  break;
8934 
8935  }
8936 
8937 
8938  exit(rc);
8939  }
8940  #endif
8941 
8942  /* DEBUG: States with branching functions */
8943  current_xmachine_firm_holder = firm_FirmCreditBankruptcy_state->agents;
8944  while(current_xmachine_firm_holder)
8945  {
8946  FLAME_debug_count = 0;
8947  /* Function: firm_credit_illiquidity_bankrupt */
8948  if(FLAME_condition_firm_firm_credit_illiquidity_bankrupt_FirmCreditBankruptcy_FirmCreditBalanceSheet(current_xmachine_firm_holder->agent)==1)
8949  { FLAME_debug_count++; }
8950  /* Function: idle */
8951  if(FLAME_condition_firm_idle_FirmCreditBankruptcy_FirmCreditPayments(current_xmachine_firm_holder->agent)==1)
8952  { FLAME_debug_count++; }
8953  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
8954  if(FLAME_debug_count != 1)
8955  {
8956  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmCreditBankruptcy'\n");
8957  if(FLAME_debug_count > 1)
8958  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
8959  if(FLAME_debug_count == 0)
8960  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
8961  }
8962 
8963  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
8964  }
8965 
8966  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_illiquidity_bankrupt\n");
8967  current_xmachine_firm_holder = firm_FirmCreditBankruptcy_state->agents;
8968  while(current_xmachine_firm_holder)
8969  {
8970  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
8971  current_xmachine_firm = current_xmachine_firm_holder->agent;
8972  current_xmachine_firm_next_state = firm_FirmCreditBalanceSheet_state;
8973  /* For backwards compatibility set current_xmachine */
8974  current_xmachine->xmachine_firm = NULL;
8975  current_xmachine->xmachine_household = NULL;
8976  current_xmachine->xmachine_equityfund = NULL;
8977  current_xmachine->xmachine_bank = NULL;
8978  current_xmachine->xmachine_government = NULL;
8979  current_xmachine->xmachine_centralbank = NULL;
8980  current_xmachine->xmachine_jpoffice = NULL;
8981  current_xmachine->xmachine_mall = NULL;
8982  current_xmachine->xmachine_reagency = NULL;
8983  current_xmachine->xmachine_firm = current_xmachine_firm;
8984 
8985  if(FLAME_condition_firm_firm_credit_illiquidity_bankrupt_FirmCreditBankruptcy_FirmCreditBalanceSheet(current_xmachine_firm)==1)
8986  {
8987 
8988 
8989 
8990  i = firm_credit_illiquidity_bankrupt();
8991 
8992 
8993 
8994  if(i == 1)
8995  {
8996  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditBankruptcy_state);
8997  }
8998  else
8999  {
9000  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditBankruptcy_state, firm_FirmCreditBalanceSheet_state);
9001  }
9002  }
9003 
9004  current_xmachine_firm = NULL;
9005 
9006  current_xmachine_firm_holder = temp_xmachine_firm_holder;
9007  }
9008  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_illiquidity_bankrupt\n");
9009 
9010 
9011  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
9012  current_xmachine_firm_holder = firm_FirmCreditBankruptcy_state->agents;
9013  while(current_xmachine_firm_holder)
9014  {
9015  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
9016  current_xmachine_firm = current_xmachine_firm_holder->agent;
9017  current_xmachine_firm_next_state = firm_FirmCreditPayments_state;
9018  /* For backwards compatibility set current_xmachine */
9019  current_xmachine->xmachine_firm = NULL;
9020  current_xmachine->xmachine_household = NULL;
9021  current_xmachine->xmachine_equityfund = NULL;
9022  current_xmachine->xmachine_bank = NULL;
9023  current_xmachine->xmachine_government = NULL;
9024  current_xmachine->xmachine_centralbank = NULL;
9025  current_xmachine->xmachine_jpoffice = NULL;
9026  current_xmachine->xmachine_mall = NULL;
9027  current_xmachine->xmachine_reagency = NULL;
9028  current_xmachine->xmachine_firm = current_xmachine_firm;
9029 
9030  if(FLAME_condition_firm_idle_FirmCreditBankruptcy_FirmCreditPayments(current_xmachine_firm)==1)
9031  {
9032 
9033 
9034 
9035  i = idle();
9036 
9037 
9038 
9039  if(i == 1)
9040  {
9041  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditBankruptcy_state);
9042  }
9043  else
9044  {
9045  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditBankruptcy_state, firm_FirmCreditPayments_state);
9046  }
9047  }
9048 
9049  current_xmachine_firm = NULL;
9050 
9051  current_xmachine_firm_holder = temp_xmachine_firm_holder;
9052  }
9053  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
9054 
9055 
9056  /* If mb is not read then leave sync complete until last possible moment */
9057  if(FLAME_bank_net_profit_message_board_read == 1)
9058  {
9059  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bank_net_profit)\n");
9060  rc = MB_SyncComplete(b_bank_net_profit);
9061  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bank_net_profit)\n");
9062  #ifdef ERRCHECK
9063  if (rc != MB_SUCCESS)
9064  {
9065  fprintf(stderr, "ERROR: Could not complete sync of 'bank_net_profit' board\n");
9066  switch(rc) {
9067  case MB_ERR_INVALID:
9068  fprintf(stderr, "\t reason: 'bank_net_profit' board is invalid\n");
9069  break;
9070  case MB_ERR_MEMALLOC:
9071  fprintf(stderr, "\t reason: out of memory\n");
9072  break;
9073  case MB_ERR_INTERNAL:
9074  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9075  break;
9076  default:
9077  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9078  break;
9079  }
9080 
9081 
9082  exit(rc);
9083  }
9084  #endif
9085 
9086 
9087 
9088  }
9089 
9090  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_credit_collect_bank_shares\n");
9091  current_xmachine_equityfund_holder = equityfund_EFCreditShareCollectionBanks_state->agents;
9092  while(current_xmachine_equityfund_holder)
9093  {
9094  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
9095  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
9096  current_xmachine_equityfund_next_state = equityfund_EFCreditShareCollectionFirms_state;
9097  /* For backwards compatibility set current_xmachine */
9098  current_xmachine->xmachine_firm = NULL;
9099  current_xmachine->xmachine_household = NULL;
9100  current_xmachine->xmachine_equityfund = NULL;
9101  current_xmachine->xmachine_bank = NULL;
9102  current_xmachine->xmachine_government = NULL;
9103  current_xmachine->xmachine_centralbank = NULL;
9104  current_xmachine->xmachine_jpoffice = NULL;
9105  current_xmachine->xmachine_mall = NULL;
9106  current_xmachine->xmachine_reagency = NULL;
9107  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
9108 
9109 
9110 
9111 
9112 
9113 
9114  rc = MB_Iterator_Create(b_bank_net_profit, &i_bank_net_profit);
9115 
9116 
9117  #ifdef ERRCHECK
9118  if (rc != MB_SUCCESS)
9119  {
9120  fprintf(stderr, "ERROR: Could not create Iterator for 'bank_net_profit'\n");
9121  switch(rc) {
9122  case MB_ERR_INVALID:
9123  fprintf(stderr, "\t reason: 'bank_net_profit' board is invalid\n");
9124  break;
9125  case MB_ERR_LOCKED:
9126  fprintf(stderr, "\t reason: 'bank_net_profit' board is locked\n");
9127  break;
9128  case MB_ERR_MEMALLOC:
9129  fprintf(stderr, "\t reason: out of memory\n");
9130  break;
9131  case MB_ERR_INTERNAL:
9132  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9133  break;
9134  default:
9135 
9136 
9137  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
9138 
9139  break;
9140  }
9141 
9142 
9143  exit(rc);
9144  }
9145  #endif
9146 
9147 
9148 
9149  i = equityfund_credit_collect_bank_shares();
9150 
9151 
9152  rc = MB_Iterator_Delete(&i_bank_net_profit);
9153  #ifdef ERRCHECK
9154  if (rc != MB_SUCCESS)
9155  {
9156  fprintf(stderr, "ERROR: Could not delete 'bank_net_profit' iterator\n");
9157  switch(rc) {
9158  case MB_ERR_INVALID:
9159  fprintf(stderr, "\t reason: 'bank_net_profit' iterator is invalid\n");
9160  break;
9161  case MB_ERR_INTERNAL:
9162  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9163  break;
9164  default:
9165  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
9166  break;
9167  }
9168 
9169 
9170  exit(rc);
9171  }
9172  #endif
9173 
9174 
9175  if(i == 1)
9176  {
9177  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditShareCollectionBanks_state);
9178  }
9179  else
9180  {
9181  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditShareCollectionBanks_state, equityfund_EFCreditShareCollectionFirms_state);
9182  }
9183 
9184 
9185  current_xmachine_equityfund = NULL;
9186 
9187  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
9188  }
9189  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_credit_collect_bank_shares\n");
9190 
9191 
9192  /* If mb is not read then leave sync complete until last possible moment */
9193  if(FLAME_household_share_message_board_read == 1)
9194  {
9195  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_household_share)\n");
9196  rc = MB_SyncComplete(b_household_share);
9197  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_household_share)\n");
9198  #ifdef ERRCHECK
9199  if (rc != MB_SUCCESS)
9200  {
9201  fprintf(stderr, "ERROR: Could not complete sync of 'household_share' board\n");
9202  switch(rc) {
9203  case MB_ERR_INVALID:
9204  fprintf(stderr, "\t reason: 'household_share' board is invalid\n");
9205  break;
9206  case MB_ERR_MEMALLOC:
9207  fprintf(stderr, "\t reason: out of memory\n");
9208  break;
9209  case MB_ERR_INTERNAL:
9210  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9211  break;
9212  default:
9213  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9214  break;
9215  }
9216 
9217 
9218  exit(rc);
9219  }
9220  #endif
9221 
9222 
9223 
9224  }
9225 
9226  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_credit_collect_shares\n");
9227  current_xmachine_household_holder = household_HHCreditIsCapitalist_state->agents;
9228  while(current_xmachine_household_holder)
9229  {
9230  temp_xmachine_household_holder = current_xmachine_household_holder->next;
9231  current_xmachine_household = current_xmachine_household_holder->agent;
9232  current_xmachine_household_next_state = household_HHCreditBalanceSheet_state;
9233  /* For backwards compatibility set current_xmachine */
9234  current_xmachine->xmachine_firm = NULL;
9235  current_xmachine->xmachine_household = NULL;
9236  current_xmachine->xmachine_equityfund = NULL;
9237  current_xmachine->xmachine_bank = NULL;
9238  current_xmachine->xmachine_government = NULL;
9239  current_xmachine->xmachine_centralbank = NULL;
9240  current_xmachine->xmachine_jpoffice = NULL;
9241  current_xmachine->xmachine_mall = NULL;
9242  current_xmachine->xmachine_reagency = NULL;
9243  current_xmachine->xmachine_household = current_xmachine_household;
9244 
9245  if(FLAME_condition_household_household_credit_collect_shares_HHCreditIsCapitalist_HHCreditBalanceSheet(current_xmachine_household)==1)
9246  {
9247 
9248 
9249 
9250 
9251  rc = MB_Iterator_Create(b_household_share, &i_household_share);
9252 
9253 
9254  #ifdef ERRCHECK
9255  if (rc != MB_SUCCESS)
9256  {
9257  fprintf(stderr, "ERROR: Could not create Iterator for 'household_share'\n");
9258  switch(rc) {
9259  case MB_ERR_INVALID:
9260  fprintf(stderr, "\t reason: 'household_share' board is invalid\n");
9261  break;
9262  case MB_ERR_LOCKED:
9263  fprintf(stderr, "\t reason: 'household_share' board is locked\n");
9264  break;
9265  case MB_ERR_MEMALLOC:
9266  fprintf(stderr, "\t reason: out of memory\n");
9267  break;
9268  case MB_ERR_INTERNAL:
9269  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9270  break;
9271  default:
9272 
9273 
9274  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
9275 
9276  break;
9277  }
9278 
9279 
9280  exit(rc);
9281  }
9282  #endif
9283 
9284 
9285 
9286  i = household_credit_collect_shares();
9287 
9288 
9289  rc = MB_Iterator_Delete(&i_household_share);
9290  #ifdef ERRCHECK
9291  if (rc != MB_SUCCESS)
9292  {
9293  fprintf(stderr, "ERROR: Could not delete 'household_share' iterator\n");
9294  switch(rc) {
9295  case MB_ERR_INVALID:
9296  fprintf(stderr, "\t reason: 'household_share' iterator is invalid\n");
9297  break;
9298  case MB_ERR_INTERNAL:
9299  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9300  break;
9301  default:
9302  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
9303  break;
9304  }
9305 
9306 
9307  exit(rc);
9308  }
9309  #endif
9310 
9311 
9312  if(i == 1)
9313  {
9314  free_household_agent(current_xmachine_household_holder, household_HHCreditIsCapitalist_state);
9315  }
9316  else
9317  {
9318  transition_household_agent(current_xmachine_household_holder, household_HHCreditIsCapitalist_state, household_HHCreditBalanceSheet_state);
9319  }
9320  }
9321 
9322  current_xmachine_household = NULL;
9323 
9324  current_xmachine_household_holder = temp_xmachine_household_holder;
9325  }
9326  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_credit_collect_shares\n");
9327 
9328 
9329  /* If mb is not read then leave sync complete until last possible moment */
9330  if(FLAME_capital_tax_message_board_read == 1)
9331  {
9332  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_capital_tax)\n");
9333  rc = MB_SyncComplete(b_capital_tax);
9334  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_capital_tax)\n");
9335  #ifdef ERRCHECK
9336  if (rc != MB_SUCCESS)
9337  {
9338  fprintf(stderr, "ERROR: Could not complete sync of 'capital_tax' board\n");
9339  switch(rc) {
9340  case MB_ERR_INVALID:
9341  fprintf(stderr, "\t reason: 'capital_tax' board is invalid\n");
9342  break;
9343  case MB_ERR_MEMALLOC:
9344  fprintf(stderr, "\t reason: out of memory\n");
9345  break;
9346  case MB_ERR_INTERNAL:
9347  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9348  break;
9349  default:
9350  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9351  break;
9352  }
9353 
9354 
9355  exit(rc);
9356  }
9357  #endif
9358 
9359 
9360 
9361  }
9362 
9363  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_collect_capital_tax\n");
9364  current_xmachine_government_holder = government_GovernmentStart_state->agents;
9365  while(current_xmachine_government_holder)
9366  {
9367  temp_xmachine_government_holder = current_xmachine_government_holder->next;
9368  current_xmachine_government = current_xmachine_government_holder->agent;
9369  current_xmachine_government_next_state = government_GovernmentCentralbankProfits_state;
9370  /* For backwards compatibility set current_xmachine */
9371  current_xmachine->xmachine_firm = NULL;
9372  current_xmachine->xmachine_household = NULL;
9373  current_xmachine->xmachine_equityfund = NULL;
9374  current_xmachine->xmachine_bank = NULL;
9375  current_xmachine->xmachine_government = NULL;
9376  current_xmachine->xmachine_centralbank = NULL;
9377  current_xmachine->xmachine_jpoffice = NULL;
9378  current_xmachine->xmachine_mall = NULL;
9379  current_xmachine->xmachine_reagency = NULL;
9380  current_xmachine->xmachine_government = current_xmachine_government;
9381 
9382  if(FLAME_condition_government_government_collect_capital_tax_GovernmentStart_GovernmentCentralbankProfits(current_xmachine_government)==1)
9383  {
9384 
9385 
9386 
9387 
9388  rc = MB_Iterator_Create(b_capital_tax, &i_capital_tax);
9389 
9390 
9391  #ifdef ERRCHECK
9392  if (rc != MB_SUCCESS)
9393  {
9394  fprintf(stderr, "ERROR: Could not create Iterator for 'capital_tax'\n");
9395  switch(rc) {
9396  case MB_ERR_INVALID:
9397  fprintf(stderr, "\t reason: 'capital_tax' board is invalid\n");
9398  break;
9399  case MB_ERR_LOCKED:
9400  fprintf(stderr, "\t reason: 'capital_tax' board is locked\n");
9401  break;
9402  case MB_ERR_MEMALLOC:
9403  fprintf(stderr, "\t reason: out of memory\n");
9404  break;
9405  case MB_ERR_INTERNAL:
9406  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9407  break;
9408  default:
9409 
9410 
9411  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
9412 
9413  break;
9414  }
9415 
9416 
9417  exit(rc);
9418  }
9419  #endif
9420 
9421 
9422 
9423  i = government_collect_capital_tax();
9424 
9425 
9426  rc = MB_Iterator_Delete(&i_capital_tax);
9427  #ifdef ERRCHECK
9428  if (rc != MB_SUCCESS)
9429  {
9430  fprintf(stderr, "ERROR: Could not delete 'capital_tax' iterator\n");
9431  switch(rc) {
9432  case MB_ERR_INVALID:
9433  fprintf(stderr, "\t reason: 'capital_tax' iterator is invalid\n");
9434  break;
9435  case MB_ERR_INTERNAL:
9436  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9437  break;
9438  default:
9439  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
9440  break;
9441  }
9442 
9443 
9444  exit(rc);
9445  }
9446  #endif
9447 
9448 
9449  if(i == 1)
9450  {
9451  free_government_agent(current_xmachine_government_holder, government_GovernmentStart_state);
9452  }
9453  else
9454  {
9455  transition_government_agent(current_xmachine_government_holder, government_GovernmentStart_state, government_GovernmentCentralbankProfits_state);
9456  }
9457  }
9458 
9459  current_xmachine_government = NULL;
9460 
9461  current_xmachine_government_holder = temp_xmachine_government_holder;
9462  }
9463  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_collect_capital_tax\n");
9464 
9465 
9466 /* End of layer number 13 */
9467 
9468 /* Clear message boards that have finished being used
9469  * and sync complete if doing late sync complete */
9470 
9471 if(FLAME_household_share_message_board_read == 0)
9472 {
9473  /*printf("%d> household_share message board sync complete late as no agents reading any messages of this type\n", node_number);*/
9474 
9475  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_household_share)\n");
9476  rc = MB_SyncComplete(b_household_share);
9477  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_household_share)\n");
9478  #ifdef ERRCHECK
9479  if (rc != MB_SUCCESS)
9480  {
9481  fprintf(stderr, "ERROR: Could not complete sync of 'household_share' board\n");
9482  switch(rc) {
9483  case MB_ERR_INVALID:
9484  fprintf(stderr, "\t reason: 'household_share' board is invalid\n");
9485  break;
9486  case MB_ERR_MEMALLOC:
9487  fprintf(stderr, "\t reason: out of memory\n");
9488  break;
9489  case MB_ERR_INTERNAL:
9490  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9491  break;
9492  default:
9493  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9494  break;
9495  }
9496 
9497 
9498  exit(rc);
9499  }
9500  #endif
9501 }
9502 
9503  /* Delete any search trees */
9504 
9505  rc = MB_Clear(b_household_share);
9506  #ifdef ERRCHECK
9507  if (rc != MB_SUCCESS)
9508  {
9509  fprintf(stderr, "ERROR: Could not clear 'household_share' board\n");
9510  switch(rc) {
9511  case MB_ERR_INVALID:
9512  fprintf(stderr, "\t reason: 'household_share' board is invalid\n");
9513  break;
9514  case MB_ERR_LOCKED:
9515  fprintf(stderr, "\t reason: 'household_share' board is locked\n");
9516  break;
9517  case MB_ERR_INTERNAL:
9518  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9519  break;
9520  default:
9521  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
9522  break;
9523 
9524  }
9525 
9526 
9527  exit(rc);
9528  }
9529  #endif
9530 
9531 if(FLAME_capital_tax_message_board_read == 0)
9532 {
9533  /*printf("%d> capital_tax message board sync complete late as no agents reading any messages of this type\n", node_number);*/
9534 
9535  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_capital_tax)\n");
9536  rc = MB_SyncComplete(b_capital_tax);
9537  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_capital_tax)\n");
9538  #ifdef ERRCHECK
9539  if (rc != MB_SUCCESS)
9540  {
9541  fprintf(stderr, "ERROR: Could not complete sync of 'capital_tax' board\n");
9542  switch(rc) {
9543  case MB_ERR_INVALID:
9544  fprintf(stderr, "\t reason: 'capital_tax' board is invalid\n");
9545  break;
9546  case MB_ERR_MEMALLOC:
9547  fprintf(stderr, "\t reason: out of memory\n");
9548  break;
9549  case MB_ERR_INTERNAL:
9550  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9551  break;
9552  default:
9553  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9554  break;
9555  }
9556 
9557 
9558  exit(rc);
9559  }
9560  #endif
9561 }
9562 
9563  /* Delete any search trees */
9564 
9565  rc = MB_Clear(b_capital_tax);
9566  #ifdef ERRCHECK
9567  if (rc != MB_SUCCESS)
9568  {
9569  fprintf(stderr, "ERROR: Could not clear 'capital_tax' board\n");
9570  switch(rc) {
9571  case MB_ERR_INVALID:
9572  fprintf(stderr, "\t reason: 'capital_tax' board is invalid\n");
9573  break;
9574  case MB_ERR_LOCKED:
9575  fprintf(stderr, "\t reason: 'capital_tax' board is locked\n");
9576  break;
9577  case MB_ERR_INTERNAL:
9578  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9579  break;
9580  default:
9581  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
9582  break;
9583 
9584  }
9585 
9586 
9587  exit(rc);
9588  }
9589  #endif
9590 
9591 if(FLAME_bank_net_profit_message_board_read == 0)
9592 {
9593  /*printf("%d> bank_net_profit message board sync complete late as no agents reading any messages of this type\n", node_number);*/
9594 
9595  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bank_net_profit)\n");
9596  rc = MB_SyncComplete(b_bank_net_profit);
9597  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bank_net_profit)\n");
9598  #ifdef ERRCHECK
9599  if (rc != MB_SUCCESS)
9600  {
9601  fprintf(stderr, "ERROR: Could not complete sync of 'bank_net_profit' board\n");
9602  switch(rc) {
9603  case MB_ERR_INVALID:
9604  fprintf(stderr, "\t reason: 'bank_net_profit' board is invalid\n");
9605  break;
9606  case MB_ERR_MEMALLOC:
9607  fprintf(stderr, "\t reason: out of memory\n");
9608  break;
9609  case MB_ERR_INTERNAL:
9610  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9611  break;
9612  default:
9613  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9614  break;
9615  }
9616 
9617 
9618  exit(rc);
9619  }
9620  #endif
9621 }
9622 
9623  /* Delete any search trees */
9624 
9625  rc = MB_Clear(b_bank_net_profit);
9626  #ifdef ERRCHECK
9627  if (rc != MB_SUCCESS)
9628  {
9629  fprintf(stderr, "ERROR: Could not clear 'bank_net_profit' board\n");
9630  switch(rc) {
9631  case MB_ERR_INVALID:
9632  fprintf(stderr, "\t reason: 'bank_net_profit' board is invalid\n");
9633  break;
9634  case MB_ERR_LOCKED:
9635  fprintf(stderr, "\t reason: 'bank_net_profit' board is locked\n");
9636  break;
9637  case MB_ERR_INTERNAL:
9638  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9639  break;
9640  default:
9641  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
9642  break;
9643 
9644  }
9645 
9646 
9647  exit(rc);
9648  }
9649  #endif
9650 
9651 
9652  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_pay_interest_on_loans\n");
9653  current_xmachine_firm_holder = firm_FirmCreditPayments_state->agents;
9654  while(current_xmachine_firm_holder)
9655  {
9656  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
9657  current_xmachine_firm = current_xmachine_firm_holder->agent;
9658  current_xmachine_firm_next_state = firm_FirmCreditDividendPayments_state;
9659  /* For backwards compatibility set current_xmachine */
9660  current_xmachine->xmachine_firm = NULL;
9661  current_xmachine->xmachine_household = NULL;
9662  current_xmachine->xmachine_equityfund = NULL;
9663  current_xmachine->xmachine_bank = NULL;
9664  current_xmachine->xmachine_government = NULL;
9665  current_xmachine->xmachine_centralbank = NULL;
9666  current_xmachine->xmachine_jpoffice = NULL;
9667  current_xmachine->xmachine_mall = NULL;
9668  current_xmachine->xmachine_reagency = NULL;
9669  current_xmachine->xmachine_firm = current_xmachine_firm;
9670 
9671 
9672 
9673 
9674 
9675  i = firm_credit_pay_interest_on_loans();
9676 
9677 
9678 
9679  if(i == 1)
9680  {
9681  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditPayments_state);
9682  }
9683  else
9684  {
9685  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditPayments_state, firm_FirmCreditDividendPayments_state);
9686  }
9687 
9688 
9689  current_xmachine_firm = NULL;
9690 
9691  current_xmachine_firm_holder = temp_xmachine_firm_holder;
9692  }
9693  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_pay_interest_on_loans\n");
9694 
9695  if(FLAME_interest_on_loan_message_board_write == 1)
9696  {
9697 
9698  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_interest_on_loan)\n");
9699  rc = MB_SyncStart(b_interest_on_loan);
9700  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_interest_on_loan)\n");
9701  #ifdef ERRCHECK
9702  if (rc != MB_SUCCESS)
9703  {
9704  fprintf(stderr, "ERROR: Could not start sync of 'interest_on_loan' board\n");
9705  switch(rc) {
9706  case MB_ERR_INVALID:
9707  fprintf(stderr, "\t reason: 'interest_on_loan' board is invalid\n");
9708  break;
9709  case MB_ERR_LOCKED:
9710  fprintf(stderr, "\t reason: 'interest_on_loan' board is locked\n");
9711  break;
9712  case MB_ERR_MEMALLOC:
9713  fprintf(stderr, "\t reason: out of memory\n");
9714  break;
9715  case MB_ERR_INTERNAL:
9716  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9717  break;
9718  default:
9719  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
9720  break;
9721  }
9722 
9723 
9724  exit(rc);
9725  }
9726  #endif
9727  }
9728 
9729 
9730 
9731  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_credit_do_balance_sheet\n");
9732  current_xmachine_household_holder = household_HHCreditBalanceSheet_state->agents;
9733  while(current_xmachine_household_holder)
9734  {
9735  temp_xmachine_household_holder = current_xmachine_household_holder->next;
9736  current_xmachine_household = current_xmachine_household_holder->agent;
9737  current_xmachine_household_next_state = household_HHCreditCheckInterestRate_state;
9738  /* For backwards compatibility set current_xmachine */
9739  current_xmachine->xmachine_firm = NULL;
9740  current_xmachine->xmachine_household = NULL;
9741  current_xmachine->xmachine_equityfund = NULL;
9742  current_xmachine->xmachine_bank = NULL;
9743  current_xmachine->xmachine_government = NULL;
9744  current_xmachine->xmachine_centralbank = NULL;
9745  current_xmachine->xmachine_jpoffice = NULL;
9746  current_xmachine->xmachine_mall = NULL;
9747  current_xmachine->xmachine_reagency = NULL;
9748  current_xmachine->xmachine_household = current_xmachine_household;
9749 
9750 
9751 
9752 
9753 
9754  i = household_credit_do_balance_sheet();
9755 
9756 
9757 
9758  if(i == 1)
9759  {
9760  free_household_agent(current_xmachine_household_holder, household_HHCreditBalanceSheet_state);
9761  }
9762  else
9763  {
9764  transition_household_agent(current_xmachine_household_holder, household_HHCreditBalanceSheet_state, household_HHCreditCheckInterestRate_state);
9765  }
9766 
9767 
9768  current_xmachine_household = NULL;
9769 
9770  current_xmachine_household_holder = temp_xmachine_household_holder;
9771  }
9772  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_credit_do_balance_sheet\n");
9773 
9774 
9775  /* If mb is not read then leave sync complete until last possible moment */
9776  if(FLAME_centralbank_government_profit_message_board_read == 1)
9777  {
9778  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_centralbank_government_profit)\n");
9779  rc = MB_SyncComplete(b_centralbank_government_profit);
9780  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_centralbank_government_profit)\n");
9781  #ifdef ERRCHECK
9782  if (rc != MB_SUCCESS)
9783  {
9784  fprintf(stderr, "ERROR: Could not complete sync of 'centralbank_government_profit' board\n");
9785  switch(rc) {
9786  case MB_ERR_INVALID:
9787  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is invalid\n");
9788  break;
9789  case MB_ERR_MEMALLOC:
9790  fprintf(stderr, "\t reason: out of memory\n");
9791  break;
9792  case MB_ERR_INTERNAL:
9793  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9794  break;
9795  default:
9796  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9797  break;
9798  }
9799 
9800 
9801  exit(rc);
9802  }
9803  #endif
9804 
9805 
9806 
9807  }
9808 
9809  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_collect_centralbank_profit\n");
9810  current_xmachine_government_holder = government_GovernmentCentralbankProfits_state->agents;
9811  while(current_xmachine_government_holder)
9812  {
9813  temp_xmachine_government_holder = current_xmachine_government_holder->next;
9814  current_xmachine_government = current_xmachine_government_holder->agent;
9815  current_xmachine_government_next_state = government_GovernmentIncomeStatement_state;
9816  /* For backwards compatibility set current_xmachine */
9817  current_xmachine->xmachine_firm = NULL;
9818  current_xmachine->xmachine_household = NULL;
9819  current_xmachine->xmachine_equityfund = NULL;
9820  current_xmachine->xmachine_bank = NULL;
9821  current_xmachine->xmachine_government = NULL;
9822  current_xmachine->xmachine_centralbank = NULL;
9823  current_xmachine->xmachine_jpoffice = NULL;
9824  current_xmachine->xmachine_mall = NULL;
9825  current_xmachine->xmachine_reagency = NULL;
9826  current_xmachine->xmachine_government = current_xmachine_government;
9827 
9828 
9829 
9830 
9831 
9832 
9833  rc = MB_Iterator_Create(b_centralbank_government_profit, &i_centralbank_government_profit);
9834 
9835 
9836  #ifdef ERRCHECK
9837  if (rc != MB_SUCCESS)
9838  {
9839  fprintf(stderr, "ERROR: Could not create Iterator for 'centralbank_government_profit'\n");
9840  switch(rc) {
9841  case MB_ERR_INVALID:
9842  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is invalid\n");
9843  break;
9844  case MB_ERR_LOCKED:
9845  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is locked\n");
9846  break;
9847  case MB_ERR_MEMALLOC:
9848  fprintf(stderr, "\t reason: out of memory\n");
9849  break;
9850  case MB_ERR_INTERNAL:
9851  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9852  break;
9853  default:
9854 
9855 
9856  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
9857 
9858  break;
9859  }
9860 
9861 
9862  exit(rc);
9863  }
9864  #endif
9865 
9866 
9867 
9868  i = government_collect_centralbank_profit();
9869 
9870 
9871  rc = MB_Iterator_Delete(&i_centralbank_government_profit);
9872  #ifdef ERRCHECK
9873  if (rc != MB_SUCCESS)
9874  {
9875  fprintf(stderr, "ERROR: Could not delete 'centralbank_government_profit' iterator\n");
9876  switch(rc) {
9877  case MB_ERR_INVALID:
9878  fprintf(stderr, "\t reason: 'centralbank_government_profit' iterator is invalid\n");
9879  break;
9880  case MB_ERR_INTERNAL:
9881  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9882  break;
9883  default:
9884  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
9885  break;
9886  }
9887 
9888 
9889  exit(rc);
9890  }
9891  #endif
9892 
9893 
9894  if(i == 1)
9895  {
9896  free_government_agent(current_xmachine_government_holder, government_GovernmentCentralbankProfits_state);
9897  }
9898  else
9899  {
9900  transition_government_agent(current_xmachine_government_holder, government_GovernmentCentralbankProfits_state, government_GovernmentIncomeStatement_state);
9901  }
9902 
9903 
9904  current_xmachine_government = NULL;
9905 
9906  current_xmachine_government_holder = temp_xmachine_government_holder;
9907  }
9908  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_collect_centralbank_profit\n");
9909 
9910 
9911 /* End of layer number 14 */
9912 
9913 /* Clear message boards that have finished being used
9914  * and sync complete if doing late sync complete */
9915 
9916 if(FLAME_centralbank_government_profit_message_board_read == 0)
9917 {
9918  /*printf("%d> centralbank_government_profit message board sync complete late as no agents reading any messages of this type\n", node_number);*/
9919 
9920  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_centralbank_government_profit)\n");
9921  rc = MB_SyncComplete(b_centralbank_government_profit);
9922  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_centralbank_government_profit)\n");
9923  #ifdef ERRCHECK
9924  if (rc != MB_SUCCESS)
9925  {
9926  fprintf(stderr, "ERROR: Could not complete sync of 'centralbank_government_profit' board\n");
9927  switch(rc) {
9928  case MB_ERR_INVALID:
9929  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is invalid\n");
9930  break;
9931  case MB_ERR_MEMALLOC:
9932  fprintf(stderr, "\t reason: out of memory\n");
9933  break;
9934  case MB_ERR_INTERNAL:
9935  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9936  break;
9937  default:
9938  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
9939  break;
9940  }
9941 
9942 
9943  exit(rc);
9944  }
9945  #endif
9946 }
9947 
9948  /* Delete any search trees */
9949 
9950  rc = MB_Clear(b_centralbank_government_profit);
9951  #ifdef ERRCHECK
9952  if (rc != MB_SUCCESS)
9953  {
9954  fprintf(stderr, "ERROR: Could not clear 'centralbank_government_profit' board\n");
9955  switch(rc) {
9956  case MB_ERR_INVALID:
9957  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is invalid\n");
9958  break;
9959  case MB_ERR_LOCKED:
9960  fprintf(stderr, "\t reason: 'centralbank_government_profit' board is locked\n");
9961  break;
9962  case MB_ERR_INTERNAL:
9963  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
9964  break;
9965  default:
9966  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
9967  break;
9968 
9969  }
9970 
9971 
9972  exit(rc);
9973  }
9974  #endif
9975 
9976 
9977  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_pay_dividends\n");
9978  current_xmachine_firm_holder = firm_FirmCreditDividendPayments_state->agents;
9979  while(current_xmachine_firm_holder)
9980  {
9981  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
9982  current_xmachine_firm = current_xmachine_firm_holder->agent;
9983  current_xmachine_firm_next_state = firm_FirmCreditBalanceSheet_state;
9984  /* For backwards compatibility set current_xmachine */
9985  current_xmachine->xmachine_firm = NULL;
9986  current_xmachine->xmachine_household = NULL;
9987  current_xmachine->xmachine_equityfund = NULL;
9988  current_xmachine->xmachine_bank = NULL;
9989  current_xmachine->xmachine_government = NULL;
9990  current_xmachine->xmachine_centralbank = NULL;
9991  current_xmachine->xmachine_jpoffice = NULL;
9992  current_xmachine->xmachine_mall = NULL;
9993  current_xmachine->xmachine_reagency = NULL;
9994  current_xmachine->xmachine_firm = current_xmachine_firm;
9995 
9996 
9997 
9998 
9999 
10000  i = firm_credit_pay_dividends();
10001 
10002 
10003 
10004  if(i == 1)
10005  {
10006  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditDividendPayments_state);
10007  }
10008  else
10009  {
10010  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditDividendPayments_state, firm_FirmCreditBalanceSheet_state);
10011  }
10012 
10013 
10014  current_xmachine_firm = NULL;
10015 
10016  current_xmachine_firm_holder = temp_xmachine_firm_holder;
10017  }
10018  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_pay_dividends\n");
10019 
10020  if(FLAME_firm_net_profit_message_board_write == 1)
10021  {
10022 
10023  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_firm_net_profit)\n");
10024  rc = MB_SyncStart(b_firm_net_profit);
10025  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_firm_net_profit)\n");
10026  #ifdef ERRCHECK
10027  if (rc != MB_SUCCESS)
10028  {
10029  fprintf(stderr, "ERROR: Could not start sync of 'firm_net_profit' board\n");
10030  switch(rc) {
10031  case MB_ERR_INVALID:
10032  fprintf(stderr, "\t reason: 'firm_net_profit' board is invalid\n");
10033  break;
10034  case MB_ERR_LOCKED:
10035  fprintf(stderr, "\t reason: 'firm_net_profit' board is locked\n");
10036  break;
10037  case MB_ERR_MEMALLOC:
10038  fprintf(stderr, "\t reason: out of memory\n");
10039  break;
10040  case MB_ERR_INTERNAL:
10041  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10042  break;
10043  default:
10044  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
10045  break;
10046  }
10047 
10048 
10049  exit(rc);
10050  }
10051  #endif
10052  }
10053 
10054 
10055 
10056  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_compute_income_statement\n");
10057  current_xmachine_government_holder = government_GovernmentIncomeStatement_state->agents;
10058  while(current_xmachine_government_holder)
10059  {
10060  temp_xmachine_government_holder = current_xmachine_government_holder->next;
10061  current_xmachine_government = current_xmachine_government_holder->agent;
10062  current_xmachine_government_next_state = government_GovernmentBalanceSheet_state;
10063  /* For backwards compatibility set current_xmachine */
10064  current_xmachine->xmachine_firm = NULL;
10065  current_xmachine->xmachine_household = NULL;
10066  current_xmachine->xmachine_equityfund = NULL;
10067  current_xmachine->xmachine_bank = NULL;
10068  current_xmachine->xmachine_government = NULL;
10069  current_xmachine->xmachine_centralbank = NULL;
10070  current_xmachine->xmachine_jpoffice = NULL;
10071  current_xmachine->xmachine_mall = NULL;
10072  current_xmachine->xmachine_reagency = NULL;
10073  current_xmachine->xmachine_government = current_xmachine_government;
10074 
10075 
10076 
10077 
10078 
10079  i = government_compute_income_statement();
10080 
10081 
10082 
10083  if(i == 1)
10084  {
10085  free_government_agent(current_xmachine_government_holder, government_GovernmentIncomeStatement_state);
10086  }
10087  else
10088  {
10089  transition_government_agent(current_xmachine_government_holder, government_GovernmentIncomeStatement_state, government_GovernmentBalanceSheet_state);
10090  }
10091 
10092 
10093  current_xmachine_government = NULL;
10094 
10095  current_xmachine_government_holder = temp_xmachine_government_holder;
10096  }
10097  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_compute_income_statement\n");
10098 
10099 
10100  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_credit_check_interest_rate\n");
10101  current_xmachine_household_holder = household_HHCreditCheckInterestRate_state->agents;
10102  while(current_xmachine_household_holder)
10103  {
10104  temp_xmachine_household_holder = current_xmachine_household_holder->next;
10105  current_xmachine_household = current_xmachine_household_holder->agent;
10106  current_xmachine_household_next_state = household_HHCreditCheckTaxRate_state;
10107  /* For backwards compatibility set current_xmachine */
10108  current_xmachine->xmachine_firm = NULL;
10109  current_xmachine->xmachine_household = NULL;
10110  current_xmachine->xmachine_equityfund = NULL;
10111  current_xmachine->xmachine_bank = NULL;
10112  current_xmachine->xmachine_government = NULL;
10113  current_xmachine->xmachine_centralbank = NULL;
10114  current_xmachine->xmachine_jpoffice = NULL;
10115  current_xmachine->xmachine_mall = NULL;
10116  current_xmachine->xmachine_reagency = NULL;
10117  current_xmachine->xmachine_household = current_xmachine_household;
10118 
10119 
10120 
10121 
10122 
10123 
10124  rc = MB_Iterator_Create(b_interest_rate, &i_interest_rate);
10125 
10126 
10127  #ifdef ERRCHECK
10128  if (rc != MB_SUCCESS)
10129  {
10130  fprintf(stderr, "ERROR: Could not create Iterator for 'interest_rate'\n");
10131  switch(rc) {
10132  case MB_ERR_INVALID:
10133  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
10134  break;
10135  case MB_ERR_LOCKED:
10136  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
10137  break;
10138  case MB_ERR_MEMALLOC:
10139  fprintf(stderr, "\t reason: out of memory\n");
10140  break;
10141  case MB_ERR_INTERNAL:
10142  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10143  break;
10144  default:
10145 
10146 
10147  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
10148 
10149  break;
10150  }
10151 
10152 
10153  exit(rc);
10154  }
10155  #endif
10156 
10157 
10158 
10159  i = household_credit_check_interest_rate();
10160 
10161 
10162  rc = MB_Iterator_Delete(&i_interest_rate);
10163  #ifdef ERRCHECK
10164  if (rc != MB_SUCCESS)
10165  {
10166  fprintf(stderr, "ERROR: Could not delete 'interest_rate' iterator\n");
10167  switch(rc) {
10168  case MB_ERR_INVALID:
10169  fprintf(stderr, "\t reason: 'interest_rate' iterator is invalid\n");
10170  break;
10171  case MB_ERR_INTERNAL:
10172  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10173  break;
10174  default:
10175  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
10176  break;
10177  }
10178 
10179 
10180  exit(rc);
10181  }
10182  #endif
10183 
10184 
10185  if(i == 1)
10186  {
10187  free_household_agent(current_xmachine_household_holder, household_HHCreditCheckInterestRate_state);
10188  }
10189  else
10190  {
10191  transition_household_agent(current_xmachine_household_holder, household_HHCreditCheckInterestRate_state, household_HHCreditCheckTaxRate_state);
10192  }
10193 
10194 
10195  current_xmachine_household = NULL;
10196 
10197  current_xmachine_household_holder = temp_xmachine_household_holder;
10198  }
10199  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_credit_check_interest_rate\n");
10200 
10201 
10202 /* End of layer number 15 */
10203 
10204 /* Clear message boards that have finished being used
10205  * and sync complete if doing late sync complete */
10206 
10207 
10208  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_do_balance_sheet\n");
10209  current_xmachine_government_holder = government_GovernmentBalanceSheet_state->agents;
10210  while(current_xmachine_government_holder)
10211  {
10212  temp_xmachine_government_holder = current_xmachine_government_holder->next;
10213  current_xmachine_government = current_xmachine_government_holder->agent;
10214  current_xmachine_government_next_state = government_GovernmentFiscalPolicy_state;
10215  /* For backwards compatibility set current_xmachine */
10216  current_xmachine->xmachine_firm = NULL;
10217  current_xmachine->xmachine_household = NULL;
10218  current_xmachine->xmachine_equityfund = NULL;
10219  current_xmachine->xmachine_bank = NULL;
10220  current_xmachine->xmachine_government = NULL;
10221  current_xmachine->xmachine_centralbank = NULL;
10222  current_xmachine->xmachine_jpoffice = NULL;
10223  current_xmachine->xmachine_mall = NULL;
10224  current_xmachine->xmachine_reagency = NULL;
10225  current_xmachine->xmachine_government = current_xmachine_government;
10226 
10227 
10228 
10229 
10230 
10231  i = government_do_balance_sheet();
10232 
10233 
10234 
10235  if(i == 1)
10236  {
10237  free_government_agent(current_xmachine_government_holder, government_GovernmentBalanceSheet_state);
10238  }
10239  else
10240  {
10241  transition_government_agent(current_xmachine_government_holder, government_GovernmentBalanceSheet_state, government_GovernmentFiscalPolicy_state);
10242  }
10243 
10244 
10245  current_xmachine_government = NULL;
10246 
10247  current_xmachine_government_holder = temp_xmachine_government_holder;
10248  }
10249  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_do_balance_sheet\n");
10250 
10251 
10252  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_do_balance_sheet\n");
10253  current_xmachine_firm_holder = firm_FirmCreditBalanceSheet_state->agents;
10254  while(current_xmachine_firm_holder)
10255  {
10256  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
10257  current_xmachine_firm = current_xmachine_firm_holder->agent;
10258  current_xmachine_firm_next_state = firm_FirmCreditCheckInterestRate_state;
10259  /* For backwards compatibility set current_xmachine */
10260  current_xmachine->xmachine_firm = NULL;
10261  current_xmachine->xmachine_household = NULL;
10262  current_xmachine->xmachine_equityfund = NULL;
10263  current_xmachine->xmachine_bank = NULL;
10264  current_xmachine->xmachine_government = NULL;
10265  current_xmachine->xmachine_centralbank = NULL;
10266  current_xmachine->xmachine_jpoffice = NULL;
10267  current_xmachine->xmachine_mall = NULL;
10268  current_xmachine->xmachine_reagency = NULL;
10269  current_xmachine->xmachine_firm = current_xmachine_firm;
10270 
10271 
10272 
10273 
10274 
10275  i = firm_credit_do_balance_sheet();
10276 
10277 
10278 
10279  if(i == 1)
10280  {
10281  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditBalanceSheet_state);
10282  }
10283  else
10284  {
10285  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditBalanceSheet_state, firm_FirmCreditCheckInterestRate_state);
10286  }
10287 
10288 
10289  current_xmachine_firm = NULL;
10290 
10291  current_xmachine_firm_holder = temp_xmachine_firm_holder;
10292  }
10293  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_do_balance_sheet\n");
10294 
10295 
10296  /* If mb is not read then leave sync complete until last possible moment */
10297  if(FLAME_firm_net_profit_message_board_read == 1)
10298  {
10299  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_firm_net_profit)\n");
10300  rc = MB_SyncComplete(b_firm_net_profit);
10301  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_firm_net_profit)\n");
10302  #ifdef ERRCHECK
10303  if (rc != MB_SUCCESS)
10304  {
10305  fprintf(stderr, "ERROR: Could not complete sync of 'firm_net_profit' board\n");
10306  switch(rc) {
10307  case MB_ERR_INVALID:
10308  fprintf(stderr, "\t reason: 'firm_net_profit' board is invalid\n");
10309  break;
10310  case MB_ERR_MEMALLOC:
10311  fprintf(stderr, "\t reason: out of memory\n");
10312  break;
10313  case MB_ERR_INTERNAL:
10314  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10315  break;
10316  default:
10317  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
10318  break;
10319  }
10320 
10321 
10322  exit(rc);
10323  }
10324  #endif
10325 
10326 
10327 
10328  }
10329 
10330  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_credit_collect_firm_shares\n");
10331  current_xmachine_equityfund_holder = equityfund_EFCreditShareCollectionFirms_state->agents;
10332  while(current_xmachine_equityfund_holder)
10333  {
10334  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
10335  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
10336  current_xmachine_equityfund_next_state = equityfund_EFCreditBalanceSheet_state;
10337  /* For backwards compatibility set current_xmachine */
10338  current_xmachine->xmachine_firm = NULL;
10339  current_xmachine->xmachine_household = NULL;
10340  current_xmachine->xmachine_equityfund = NULL;
10341  current_xmachine->xmachine_bank = NULL;
10342  current_xmachine->xmachine_government = NULL;
10343  current_xmachine->xmachine_centralbank = NULL;
10344  current_xmachine->xmachine_jpoffice = NULL;
10345  current_xmachine->xmachine_mall = NULL;
10346  current_xmachine->xmachine_reagency = NULL;
10347  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
10348 
10349 
10350 
10351 
10352 
10353 
10354  rc = MB_Iterator_Create(b_firm_net_profit, &i_firm_net_profit);
10355 
10356 
10357  #ifdef ERRCHECK
10358  if (rc != MB_SUCCESS)
10359  {
10360  fprintf(stderr, "ERROR: Could not create Iterator for 'firm_net_profit'\n");
10361  switch(rc) {
10362  case MB_ERR_INVALID:
10363  fprintf(stderr, "\t reason: 'firm_net_profit' board is invalid\n");
10364  break;
10365  case MB_ERR_LOCKED:
10366  fprintf(stderr, "\t reason: 'firm_net_profit' board is locked\n");
10367  break;
10368  case MB_ERR_MEMALLOC:
10369  fprintf(stderr, "\t reason: out of memory\n");
10370  break;
10371  case MB_ERR_INTERNAL:
10372  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10373  break;
10374  default:
10375 
10376 
10377  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
10378 
10379  break;
10380  }
10381 
10382 
10383  exit(rc);
10384  }
10385  #endif
10386 
10387 
10388 
10389  i = equityfund_credit_collect_firm_shares();
10390 
10391 
10392  rc = MB_Iterator_Delete(&i_firm_net_profit);
10393  #ifdef ERRCHECK
10394  if (rc != MB_SUCCESS)
10395  {
10396  fprintf(stderr, "ERROR: Could not delete 'firm_net_profit' iterator\n");
10397  switch(rc) {
10398  case MB_ERR_INVALID:
10399  fprintf(stderr, "\t reason: 'firm_net_profit' iterator is invalid\n");
10400  break;
10401  case MB_ERR_INTERNAL:
10402  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10403  break;
10404  default:
10405  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
10406  break;
10407  }
10408 
10409 
10410  exit(rc);
10411  }
10412  #endif
10413 
10414 
10415  if(i == 1)
10416  {
10417  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditShareCollectionFirms_state);
10418  }
10419  else
10420  {
10421  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditShareCollectionFirms_state, equityfund_EFCreditBalanceSheet_state);
10422  }
10423 
10424 
10425  current_xmachine_equityfund = NULL;
10426 
10427  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
10428  }
10429  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_credit_collect_firm_shares\n");
10430 
10431 
10432 /* End of layer number 16 */
10433 
10434 /* Clear message boards that have finished being used
10435  * and sync complete if doing late sync complete */
10436 
10437 if(FLAME_firm_net_profit_message_board_read == 0)
10438 {
10439  /*printf("%d> firm_net_profit message board sync complete late as no agents reading any messages of this type\n", node_number);*/
10440 
10441  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_firm_net_profit)\n");
10442  rc = MB_SyncComplete(b_firm_net_profit);
10443  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_firm_net_profit)\n");
10444  #ifdef ERRCHECK
10445  if (rc != MB_SUCCESS)
10446  {
10447  fprintf(stderr, "ERROR: Could not complete sync of 'firm_net_profit' board\n");
10448  switch(rc) {
10449  case MB_ERR_INVALID:
10450  fprintf(stderr, "\t reason: 'firm_net_profit' board is invalid\n");
10451  break;
10452  case MB_ERR_MEMALLOC:
10453  fprintf(stderr, "\t reason: out of memory\n");
10454  break;
10455  case MB_ERR_INTERNAL:
10456  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10457  break;
10458  default:
10459  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
10460  break;
10461  }
10462 
10463 
10464  exit(rc);
10465  }
10466  #endif
10467 }
10468 
10469  /* Delete any search trees */
10470 
10471  rc = MB_Clear(b_firm_net_profit);
10472  #ifdef ERRCHECK
10473  if (rc != MB_SUCCESS)
10474  {
10475  fprintf(stderr, "ERROR: Could not clear 'firm_net_profit' board\n");
10476  switch(rc) {
10477  case MB_ERR_INVALID:
10478  fprintf(stderr, "\t reason: 'firm_net_profit' board is invalid\n");
10479  break;
10480  case MB_ERR_LOCKED:
10481  fprintf(stderr, "\t reason: 'firm_net_profit' board is locked\n");
10482  break;
10483  case MB_ERR_INTERNAL:
10484  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10485  break;
10486  default:
10487  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
10488  break;
10489 
10490  }
10491 
10492 
10493  exit(rc);
10494  }
10495  #endif
10496 
10497 
10498  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_update_fiscal_policy\n");
10499  current_xmachine_government_holder = government_GovernmentFiscalPolicy_state->agents;
10500  while(current_xmachine_government_holder)
10501  {
10502  temp_xmachine_government_holder = current_xmachine_government_holder->next;
10503  current_xmachine_government = current_xmachine_government_holder->agent;
10504  current_xmachine_government_next_state = government_GovernmentMonthly_state;
10505  /* For backwards compatibility set current_xmachine */
10506  current_xmachine->xmachine_firm = NULL;
10507  current_xmachine->xmachine_household = NULL;
10508  current_xmachine->xmachine_equityfund = NULL;
10509  current_xmachine->xmachine_bank = NULL;
10510  current_xmachine->xmachine_government = NULL;
10511  current_xmachine->xmachine_centralbank = NULL;
10512  current_xmachine->xmachine_jpoffice = NULL;
10513  current_xmachine->xmachine_mall = NULL;
10514  current_xmachine->xmachine_reagency = NULL;
10515  current_xmachine->xmachine_government = current_xmachine_government;
10516 
10517 
10518 
10519 
10520 
10521  i = government_update_fiscal_policy();
10522 
10523 
10524 
10525  if(i == 1)
10526  {
10527  free_government_agent(current_xmachine_government_holder, government_GovernmentFiscalPolicy_state);
10528  }
10529  else
10530  {
10531  transition_government_agent(current_xmachine_government_holder, government_GovernmentFiscalPolicy_state, government_GovernmentMonthly_state);
10532  }
10533 
10534 
10535  current_xmachine_government = NULL;
10536 
10537  current_xmachine_government_holder = temp_xmachine_government_holder;
10538  }
10539  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_update_fiscal_policy\n");
10540 
10541  if(FLAME_tax_rate_message_board_write == 1)
10542  {
10543 
10544  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_tax_rate)\n");
10545  rc = MB_SyncStart(b_tax_rate);
10546  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_tax_rate)\n");
10547  #ifdef ERRCHECK
10548  if (rc != MB_SUCCESS)
10549  {
10550  fprintf(stderr, "ERROR: Could not start sync of 'tax_rate' board\n");
10551  switch(rc) {
10552  case MB_ERR_INVALID:
10553  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
10554  break;
10555  case MB_ERR_LOCKED:
10556  fprintf(stderr, "\t reason: 'tax_rate' board is locked\n");
10557  break;
10558  case MB_ERR_MEMALLOC:
10559  fprintf(stderr, "\t reason: out of memory\n");
10560  break;
10561  case MB_ERR_INTERNAL:
10562  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10563  break;
10564  default:
10565  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
10566  break;
10567  }
10568 
10569 
10570  exit(rc);
10571  }
10572  #endif
10573  }
10574 
10575 
10576 
10577  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_credit_do_balance_sheet\n");
10578  current_xmachine_equityfund_holder = equityfund_EFCreditBalanceSheet_state->agents;
10579  while(current_xmachine_equityfund_holder)
10580  {
10581  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
10582  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
10583  current_xmachine_equityfund_next_state = equityfund_EFCreditCheckTaxRate_state;
10584  /* For backwards compatibility set current_xmachine */
10585  current_xmachine->xmachine_firm = NULL;
10586  current_xmachine->xmachine_household = NULL;
10587  current_xmachine->xmachine_equityfund = NULL;
10588  current_xmachine->xmachine_bank = NULL;
10589  current_xmachine->xmachine_government = NULL;
10590  current_xmachine->xmachine_centralbank = NULL;
10591  current_xmachine->xmachine_jpoffice = NULL;
10592  current_xmachine->xmachine_mall = NULL;
10593  current_xmachine->xmachine_reagency = NULL;
10594  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
10595 
10596 
10597 
10598 
10599 
10600  i = equityfund_credit_do_balance_sheet();
10601 
10602 
10603 
10604  if(i == 1)
10605  {
10606  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditBalanceSheet_state);
10607  }
10608  else
10609  {
10610  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditBalanceSheet_state, equityfund_EFCreditCheckTaxRate_state);
10611  }
10612 
10613 
10614  current_xmachine_equityfund = NULL;
10615 
10616  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
10617  }
10618  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_credit_do_balance_sheet\n");
10619 
10620 
10621  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_check_interest_rate\n");
10622  current_xmachine_firm_holder = firm_FirmCreditCheckInterestRate_state->agents;
10623  while(current_xmachine_firm_holder)
10624  {
10625  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
10626  current_xmachine_firm = current_xmachine_firm_holder->agent;
10627  current_xmachine_firm_next_state = firm_FirmCreditCheckTaxRate_state;
10628  /* For backwards compatibility set current_xmachine */
10629  current_xmachine->xmachine_firm = NULL;
10630  current_xmachine->xmachine_household = NULL;
10631  current_xmachine->xmachine_equityfund = NULL;
10632  current_xmachine->xmachine_bank = NULL;
10633  current_xmachine->xmachine_government = NULL;
10634  current_xmachine->xmachine_centralbank = NULL;
10635  current_xmachine->xmachine_jpoffice = NULL;
10636  current_xmachine->xmachine_mall = NULL;
10637  current_xmachine->xmachine_reagency = NULL;
10638  current_xmachine->xmachine_firm = current_xmachine_firm;
10639 
10640 
10641 
10642 
10643 
10644 
10645  rc = MB_Iterator_Create(b_interest_rate, &i_interest_rate);
10646 
10647 
10648  #ifdef ERRCHECK
10649  if (rc != MB_SUCCESS)
10650  {
10651  fprintf(stderr, "ERROR: Could not create Iterator for 'interest_rate'\n");
10652  switch(rc) {
10653  case MB_ERR_INVALID:
10654  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
10655  break;
10656  case MB_ERR_LOCKED:
10657  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
10658  break;
10659  case MB_ERR_MEMALLOC:
10660  fprintf(stderr, "\t reason: out of memory\n");
10661  break;
10662  case MB_ERR_INTERNAL:
10663  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10664  break;
10665  default:
10666 
10667 
10668  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
10669 
10670  break;
10671  }
10672 
10673 
10674  exit(rc);
10675  }
10676  #endif
10677 
10678 
10679 
10680  i = firm_credit_check_interest_rate();
10681 
10682 
10683  rc = MB_Iterator_Delete(&i_interest_rate);
10684  #ifdef ERRCHECK
10685  if (rc != MB_SUCCESS)
10686  {
10687  fprintf(stderr, "ERROR: Could not delete 'interest_rate' iterator\n");
10688  switch(rc) {
10689  case MB_ERR_INVALID:
10690  fprintf(stderr, "\t reason: 'interest_rate' iterator is invalid\n");
10691  break;
10692  case MB_ERR_INTERNAL:
10693  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10694  break;
10695  default:
10696  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
10697  break;
10698  }
10699 
10700 
10701  exit(rc);
10702  }
10703  #endif
10704 
10705 
10706  if(i == 1)
10707  {
10708  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditCheckInterestRate_state);
10709  }
10710  else
10711  {
10712  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditCheckInterestRate_state, firm_FirmCreditCheckTaxRate_state);
10713  }
10714 
10715 
10716  current_xmachine_firm = NULL;
10717 
10718  current_xmachine_firm_holder = temp_xmachine_firm_holder;
10719  }
10720  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_check_interest_rate\n");
10721 
10722 
10723 /* End of layer number 17 */
10724 
10725 /* Clear message boards that have finished being used
10726  * and sync complete if doing late sync complete */
10727 
10728  /* DEBUG: States with branching functions */
10729  current_xmachine_government_holder = government_GovernmentMonthly_state->agents;
10730  while(current_xmachine_government_holder)
10731  {
10732  FLAME_debug_count = 0;
10733  /* Function: government_distribute_general_benefits */
10734  if(FLAME_condition_government_government_distribute_general_benefits_GovernmentMonthly_GovernmentUnemploymentBenefits(current_xmachine_government_holder->agent)==1)
10735  { FLAME_debug_count++; }
10736  /* Function: idle */
10737  if(FLAME_condition_government_idle_GovernmentMonthly_end(current_xmachine_government_holder->agent)==1)
10738  { FLAME_debug_count++; }
10739  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
10740  if(FLAME_debug_count != 1)
10741  {
10742  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'government' leaving state 'GovernmentMonthly'\n");
10743  if(FLAME_debug_count > 1)
10744  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
10745  if(FLAME_debug_count == 0)
10746  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
10747  }
10748 
10749  current_xmachine_government_holder = current_xmachine_government_holder->next;
10750  }
10751 
10752  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_distribute_general_benefits\n");
10753  current_xmachine_government_holder = government_GovernmentMonthly_state->agents;
10754  while(current_xmachine_government_holder)
10755  {
10756  temp_xmachine_government_holder = current_xmachine_government_holder->next;
10757  current_xmachine_government = current_xmachine_government_holder->agent;
10758  current_xmachine_government_next_state = government_GovernmentUnemploymentBenefits_state;
10759  /* For backwards compatibility set current_xmachine */
10760  current_xmachine->xmachine_firm = NULL;
10761  current_xmachine->xmachine_household = NULL;
10762  current_xmachine->xmachine_equityfund = NULL;
10763  current_xmachine->xmachine_bank = NULL;
10764  current_xmachine->xmachine_government = NULL;
10765  current_xmachine->xmachine_centralbank = NULL;
10766  current_xmachine->xmachine_jpoffice = NULL;
10767  current_xmachine->xmachine_mall = NULL;
10768  current_xmachine->xmachine_reagency = NULL;
10769  current_xmachine->xmachine_government = current_xmachine_government;
10770 
10771  if(FLAME_condition_government_government_distribute_general_benefits_GovernmentMonthly_GovernmentUnemploymentBenefits(current_xmachine_government)==1)
10772  {
10773 
10774 
10775 
10776  i = government_distribute_general_benefits();
10777 
10778 
10779 
10780  if(i == 1)
10781  {
10782  free_government_agent(current_xmachine_government_holder, government_GovernmentMonthly_state);
10783  }
10784  else
10785  {
10786  transition_government_agent(current_xmachine_government_holder, government_GovernmentMonthly_state, government_GovernmentUnemploymentBenefits_state);
10787  }
10788  }
10789 
10790  current_xmachine_government = NULL;
10791 
10792  current_xmachine_government_holder = temp_xmachine_government_holder;
10793  }
10794  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_distribute_general_benefits\n");
10795 
10796  if(FLAME_general_benefit_message_board_write == 1)
10797  {
10798 
10799  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_general_benefit)\n");
10800  rc = MB_SyncStart(b_general_benefit);
10801  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_general_benefit)\n");
10802  #ifdef ERRCHECK
10803  if (rc != MB_SUCCESS)
10804  {
10805  fprintf(stderr, "ERROR: Could not start sync of 'general_benefit' board\n");
10806  switch(rc) {
10807  case MB_ERR_INVALID:
10808  fprintf(stderr, "\t reason: 'general_benefit' board is invalid\n");
10809  break;
10810  case MB_ERR_LOCKED:
10811  fprintf(stderr, "\t reason: 'general_benefit' board is locked\n");
10812  break;
10813  case MB_ERR_MEMALLOC:
10814  fprintf(stderr, "\t reason: out of memory\n");
10815  break;
10816  case MB_ERR_INTERNAL:
10817  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10818  break;
10819  default:
10820  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
10821  break;
10822  }
10823 
10824 
10825  exit(rc);
10826  }
10827  #endif
10828  }
10829 
10830 
10831 
10832  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
10833  current_xmachine_government_holder = government_GovernmentMonthly_state->agents;
10834  while(current_xmachine_government_holder)
10835  {
10836  temp_xmachine_government_holder = current_xmachine_government_holder->next;
10837  current_xmachine_government = current_xmachine_government_holder->agent;
10838  current_xmachine_government_next_state = government_end_state;
10839  /* For backwards compatibility set current_xmachine */
10840  current_xmachine->xmachine_firm = NULL;
10841  current_xmachine->xmachine_household = NULL;
10842  current_xmachine->xmachine_equityfund = NULL;
10843  current_xmachine->xmachine_bank = NULL;
10844  current_xmachine->xmachine_government = NULL;
10845  current_xmachine->xmachine_centralbank = NULL;
10846  current_xmachine->xmachine_jpoffice = NULL;
10847  current_xmachine->xmachine_mall = NULL;
10848  current_xmachine->xmachine_reagency = NULL;
10849  current_xmachine->xmachine_government = current_xmachine_government;
10850 
10851  if(FLAME_condition_government_idle_GovernmentMonthly_end(current_xmachine_government)==1)
10852  {
10853 
10854 
10855 
10856  i = idle();
10857 
10858 
10859 
10860  if(i == 1)
10861  {
10862  free_government_agent(current_xmachine_government_holder, government_GovernmentMonthly_state);
10863  }
10864  else
10865  {
10866  transition_government_agent(current_xmachine_government_holder, government_GovernmentMonthly_state, government_end_state);
10867  }
10868  }
10869 
10870  current_xmachine_government = NULL;
10871 
10872  current_xmachine_government_holder = temp_xmachine_government_holder;
10873  }
10874  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
10875 
10876 
10877  /* If mb is not read then leave sync complete until last possible moment */
10878  if(FLAME_tax_rate_message_board_read == 1)
10879  {
10880  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_tax_rate)\n");
10881  rc = MB_SyncComplete(b_tax_rate);
10882  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_tax_rate)\n");
10883  #ifdef ERRCHECK
10884  if (rc != MB_SUCCESS)
10885  {
10886  fprintf(stderr, "ERROR: Could not complete sync of 'tax_rate' board\n");
10887  switch(rc) {
10888  case MB_ERR_INVALID:
10889  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
10890  break;
10891  case MB_ERR_MEMALLOC:
10892  fprintf(stderr, "\t reason: out of memory\n");
10893  break;
10894  case MB_ERR_INTERNAL:
10895  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10896  break;
10897  default:
10898  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
10899  break;
10900  }
10901 
10902 
10903  exit(rc);
10904  }
10905  #endif
10906 
10907 
10908 
10909  }
10910 
10911  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_check_tax_rate\n");
10912  current_xmachine_firm_holder = firm_FirmCreditCheckTaxRate_state->agents;
10913  while(current_xmachine_firm_holder)
10914  {
10915  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
10916  current_xmachine_firm = current_xmachine_firm_holder->agent;
10917  current_xmachine_firm_next_state = firm_FirmCreditInsolvencyCheck_state;
10918  /* For backwards compatibility set current_xmachine */
10919  current_xmachine->xmachine_firm = NULL;
10920  current_xmachine->xmachine_household = NULL;
10921  current_xmachine->xmachine_equityfund = NULL;
10922  current_xmachine->xmachine_bank = NULL;
10923  current_xmachine->xmachine_government = NULL;
10924  current_xmachine->xmachine_centralbank = NULL;
10925  current_xmachine->xmachine_jpoffice = NULL;
10926  current_xmachine->xmachine_mall = NULL;
10927  current_xmachine->xmachine_reagency = NULL;
10928  current_xmachine->xmachine_firm = current_xmachine_firm;
10929 
10930 
10931 
10932 
10933 
10934 
10935  rc = MB_Iterator_Create(b_tax_rate, &i_tax_rate);
10936 
10937 
10938  #ifdef ERRCHECK
10939  if (rc != MB_SUCCESS)
10940  {
10941  fprintf(stderr, "ERROR: Could not create Iterator for 'tax_rate'\n");
10942  switch(rc) {
10943  case MB_ERR_INVALID:
10944  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
10945  break;
10946  case MB_ERR_LOCKED:
10947  fprintf(stderr, "\t reason: 'tax_rate' board is locked\n");
10948  break;
10949  case MB_ERR_MEMALLOC:
10950  fprintf(stderr, "\t reason: out of memory\n");
10951  break;
10952  case MB_ERR_INTERNAL:
10953  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10954  break;
10955  default:
10956 
10957 
10958  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
10959 
10960  break;
10961  }
10962 
10963 
10964  exit(rc);
10965  }
10966  #endif
10967 
10968 
10969 
10970  i = firm_credit_check_tax_rate();
10971 
10972 
10973  rc = MB_Iterator_Delete(&i_tax_rate);
10974  #ifdef ERRCHECK
10975  if (rc != MB_SUCCESS)
10976  {
10977  fprintf(stderr, "ERROR: Could not delete 'tax_rate' iterator\n");
10978  switch(rc) {
10979  case MB_ERR_INVALID:
10980  fprintf(stderr, "\t reason: 'tax_rate' iterator is invalid\n");
10981  break;
10982  case MB_ERR_INTERNAL:
10983  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
10984  break;
10985  default:
10986  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
10987  break;
10988  }
10989 
10990 
10991  exit(rc);
10992  }
10993  #endif
10994 
10995 
10996  if(i == 1)
10997  {
10998  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditCheckTaxRate_state);
10999  }
11000  else
11001  {
11002  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditCheckTaxRate_state, firm_FirmCreditInsolvencyCheck_state);
11003  }
11004 
11005 
11006  current_xmachine_firm = NULL;
11007 
11008  current_xmachine_firm_holder = temp_xmachine_firm_holder;
11009  }
11010  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_check_tax_rate\n");
11011 
11012 
11013  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_credit_check_tax_rate\n");
11014  current_xmachine_household_holder = household_HHCreditCheckTaxRate_state->agents;
11015  while(current_xmachine_household_holder)
11016  {
11017  temp_xmachine_household_holder = current_xmachine_household_holder->next;
11018  current_xmachine_household = current_xmachine_household_holder->agent;
11019  current_xmachine_household_next_state = household_HHCreditMonthly_state;
11020  /* For backwards compatibility set current_xmachine */
11021  current_xmachine->xmachine_firm = NULL;
11022  current_xmachine->xmachine_household = NULL;
11023  current_xmachine->xmachine_equityfund = NULL;
11024  current_xmachine->xmachine_bank = NULL;
11025  current_xmachine->xmachine_government = NULL;
11026  current_xmachine->xmachine_centralbank = NULL;
11027  current_xmachine->xmachine_jpoffice = NULL;
11028  current_xmachine->xmachine_mall = NULL;
11029  current_xmachine->xmachine_reagency = NULL;
11030  current_xmachine->xmachine_household = current_xmachine_household;
11031 
11032 
11033 
11034 
11035 
11036 
11037  rc = MB_Iterator_Create(b_tax_rate, &i_tax_rate);
11038 
11039 
11040  #ifdef ERRCHECK
11041  if (rc != MB_SUCCESS)
11042  {
11043  fprintf(stderr, "ERROR: Could not create Iterator for 'tax_rate'\n");
11044  switch(rc) {
11045  case MB_ERR_INVALID:
11046  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
11047  break;
11048  case MB_ERR_LOCKED:
11049  fprintf(stderr, "\t reason: 'tax_rate' board is locked\n");
11050  break;
11051  case MB_ERR_MEMALLOC:
11052  fprintf(stderr, "\t reason: out of memory\n");
11053  break;
11054  case MB_ERR_INTERNAL:
11055  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11056  break;
11057  default:
11058 
11059 
11060  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
11061 
11062  break;
11063  }
11064 
11065 
11066  exit(rc);
11067  }
11068  #endif
11069 
11070 
11071 
11072  i = household_credit_check_tax_rate();
11073 
11074 
11075  rc = MB_Iterator_Delete(&i_tax_rate);
11076  #ifdef ERRCHECK
11077  if (rc != MB_SUCCESS)
11078  {
11079  fprintf(stderr, "ERROR: Could not delete 'tax_rate' iterator\n");
11080  switch(rc) {
11081  case MB_ERR_INVALID:
11082  fprintf(stderr, "\t reason: 'tax_rate' iterator is invalid\n");
11083  break;
11084  case MB_ERR_INTERNAL:
11085  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11086  break;
11087  default:
11088  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
11089  break;
11090  }
11091 
11092 
11093  exit(rc);
11094  }
11095  #endif
11096 
11097 
11098  if(i == 1)
11099  {
11100  free_household_agent(current_xmachine_household_holder, household_HHCreditCheckTaxRate_state);
11101  }
11102  else
11103  {
11104  transition_household_agent(current_xmachine_household_holder, household_HHCreditCheckTaxRate_state, household_HHCreditMonthly_state);
11105  }
11106 
11107 
11108  current_xmachine_household = NULL;
11109 
11110  current_xmachine_household_holder = temp_xmachine_household_holder;
11111  }
11112  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_credit_check_tax_rate\n");
11113 
11114 
11115  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_credit_check_tax_rate\n");
11116  current_xmachine_equityfund_holder = equityfund_EFCreditCheckTaxRate_state->agents;
11117  while(current_xmachine_equityfund_holder)
11118  {
11119  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
11120  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
11121  current_xmachine_equityfund_next_state = equityfund_EFLabourMarket_state;
11122  /* For backwards compatibility set current_xmachine */
11123  current_xmachine->xmachine_firm = NULL;
11124  current_xmachine->xmachine_household = NULL;
11125  current_xmachine->xmachine_equityfund = NULL;
11126  current_xmachine->xmachine_bank = NULL;
11127  current_xmachine->xmachine_government = NULL;
11128  current_xmachine->xmachine_centralbank = NULL;
11129  current_xmachine->xmachine_jpoffice = NULL;
11130  current_xmachine->xmachine_mall = NULL;
11131  current_xmachine->xmachine_reagency = NULL;
11132  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
11133 
11134 
11135 
11136 
11137 
11138 
11139  rc = MB_Iterator_Create(b_tax_rate, &i_tax_rate);
11140 
11141 
11142  #ifdef ERRCHECK
11143  if (rc != MB_SUCCESS)
11144  {
11145  fprintf(stderr, "ERROR: Could not create Iterator for 'tax_rate'\n");
11146  switch(rc) {
11147  case MB_ERR_INVALID:
11148  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
11149  break;
11150  case MB_ERR_LOCKED:
11151  fprintf(stderr, "\t reason: 'tax_rate' board is locked\n");
11152  break;
11153  case MB_ERR_MEMALLOC:
11154  fprintf(stderr, "\t reason: out of memory\n");
11155  break;
11156  case MB_ERR_INTERNAL:
11157  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11158  break;
11159  default:
11160 
11161 
11162  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
11163 
11164  break;
11165  }
11166 
11167 
11168  exit(rc);
11169  }
11170  #endif
11171 
11172 
11173 
11174  i = equityfund_credit_check_tax_rate();
11175 
11176 
11177  rc = MB_Iterator_Delete(&i_tax_rate);
11178  #ifdef ERRCHECK
11179  if (rc != MB_SUCCESS)
11180  {
11181  fprintf(stderr, "ERROR: Could not delete 'tax_rate' iterator\n");
11182  switch(rc) {
11183  case MB_ERR_INVALID:
11184  fprintf(stderr, "\t reason: 'tax_rate' iterator is invalid\n");
11185  break;
11186  case MB_ERR_INTERNAL:
11187  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11188  break;
11189  default:
11190  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
11191  break;
11192  }
11193 
11194 
11195  exit(rc);
11196  }
11197  #endif
11198 
11199 
11200  if(i == 1)
11201  {
11202  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditCheckTaxRate_state);
11203  }
11204  else
11205  {
11206  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFCreditCheckTaxRate_state, equityfund_EFLabourMarket_state);
11207  }
11208 
11209 
11210  current_xmachine_equityfund = NULL;
11211 
11212  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
11213  }
11214  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_credit_check_tax_rate\n");
11215 
11216 
11217 /* End of layer number 18 */
11218 
11219 /* Clear message boards that have finished being used
11220  * and sync complete if doing late sync complete */
11221 
11222 if(FLAME_tax_rate_message_board_read == 0)
11223 {
11224  /*printf("%d> tax_rate message board sync complete late as no agents reading any messages of this type\n", node_number);*/
11225 
11226  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_tax_rate)\n");
11227  rc = MB_SyncComplete(b_tax_rate);
11228  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_tax_rate)\n");
11229  #ifdef ERRCHECK
11230  if (rc != MB_SUCCESS)
11231  {
11232  fprintf(stderr, "ERROR: Could not complete sync of 'tax_rate' board\n");
11233  switch(rc) {
11234  case MB_ERR_INVALID:
11235  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
11236  break;
11237  case MB_ERR_MEMALLOC:
11238  fprintf(stderr, "\t reason: out of memory\n");
11239  break;
11240  case MB_ERR_INTERNAL:
11241  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11242  break;
11243  default:
11244  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
11245  break;
11246  }
11247 
11248 
11249  exit(rc);
11250  }
11251  #endif
11252 }
11253 
11254  /* Delete any search trees */
11255 
11256  rc = MB_Clear(b_tax_rate);
11257  #ifdef ERRCHECK
11258  if (rc != MB_SUCCESS)
11259  {
11260  fprintf(stderr, "ERROR: Could not clear 'tax_rate' board\n");
11261  switch(rc) {
11262  case MB_ERR_INVALID:
11263  fprintf(stderr, "\t reason: 'tax_rate' board is invalid\n");
11264  break;
11265  case MB_ERR_LOCKED:
11266  fprintf(stderr, "\t reason: 'tax_rate' board is locked\n");
11267  break;
11268  case MB_ERR_INTERNAL:
11269  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11270  break;
11271  default:
11272  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
11273  break;
11274 
11275  }
11276 
11277 
11278  exit(rc);
11279  }
11280  #endif
11281 
11282  /* DEBUG: States with branching functions */
11283  current_xmachine_firm_holder = firm_FirmCreditInsolvencyCheck_state->agents;
11284  while(current_xmachine_firm_holder)
11285  {
11286  FLAME_debug_count = 0;
11287  /* Function: firm_credit_insolvency_bankruptcy */
11288  if(FLAME_condition_firm_firm_credit_insolvency_bankruptcy_FirmCreditInsolvencyCheck_FirmProductionStart(current_xmachine_firm_holder->agent)==1)
11289  { FLAME_debug_count++; }
11290  /* Function: idle */
11291  if(FLAME_condition_firm_idle_FirmCreditInsolvencyCheck_FirmProductionStart(current_xmachine_firm_holder->agent)==1)
11292  { FLAME_debug_count++; }
11293  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
11294  if(FLAME_debug_count != 1)
11295  {
11296  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmCreditInsolvencyCheck'\n");
11297  if(FLAME_debug_count > 1)
11298  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
11299  if(FLAME_debug_count == 0)
11300  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
11301  }
11302 
11303  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
11304  }
11305  /* DEBUG: States with branching functions */
11306  current_xmachine_household_holder = household_HHCreditMonthly_state->agents;
11307  while(current_xmachine_household_holder)
11308  {
11309  FLAME_debug_count = 0;
11310  /* Function: household_credit_collect_benefits */
11311  if(FLAME_condition_household_household_credit_collect_benefits_HHCreditMonthly_HHCreditEmployment(current_xmachine_household_holder->agent)==1)
11312  { FLAME_debug_count++; }
11313  /* Function: idle */
11314  if(FLAME_condition_household_idle_HHCreditMonthly_HHLabourStart(current_xmachine_household_holder->agent)==1)
11315  { FLAME_debug_count++; }
11316  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
11317  if(FLAME_debug_count != 1)
11318  {
11319  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHCreditMonthly'\n");
11320  if(FLAME_debug_count > 1)
11321  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
11322  if(FLAME_debug_count == 0)
11323  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
11324  }
11325 
11326  current_xmachine_household_holder = current_xmachine_household_holder->next;
11327  }
11328  /* DEBUG: States with branching functions */
11329  current_xmachine_equityfund_holder = equityfund_EFLabourMarket_state->agents;
11330  while(current_xmachine_equityfund_holder)
11331  {
11332  FLAME_debug_count = 0;
11333  /* Function: equityfund_audit_dividends */
11334  if(FLAME_condition_equityfund_equityfund_audit_dividends_EFLabourMarket_end(current_xmachine_equityfund_holder->agent)==1)
11335  { FLAME_debug_count++; }
11336  /* Function: idle */
11337  if(FLAME_condition_equityfund_idle_EFLabourMarket_end(current_xmachine_equityfund_holder->agent)==1)
11338  { FLAME_debug_count++; }
11339  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
11340  if(FLAME_debug_count != 1)
11341  {
11342  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'equityfund' leaving state 'EFLabourMarket'\n");
11343  if(FLAME_debug_count > 1)
11344  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
11345  if(FLAME_debug_count == 0)
11346  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
11347  }
11348 
11349  current_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
11350  }
11351 
11352  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_distribute_unemployment_benefits\n");
11353  current_xmachine_government_holder = government_GovernmentUnemploymentBenefits_state->agents;
11354  while(current_xmachine_government_holder)
11355  {
11356  temp_xmachine_government_holder = current_xmachine_government_holder->next;
11357  current_xmachine_government = current_xmachine_government_holder->agent;
11358  current_xmachine_government_next_state = government_GovernmentLabourTax_state;
11359  /* For backwards compatibility set current_xmachine */
11360  current_xmachine->xmachine_firm = NULL;
11361  current_xmachine->xmachine_household = NULL;
11362  current_xmachine->xmachine_equityfund = NULL;
11363  current_xmachine->xmachine_bank = NULL;
11364  current_xmachine->xmachine_government = NULL;
11365  current_xmachine->xmachine_centralbank = NULL;
11366  current_xmachine->xmachine_jpoffice = NULL;
11367  current_xmachine->xmachine_mall = NULL;
11368  current_xmachine->xmachine_reagency = NULL;
11369  current_xmachine->xmachine_government = current_xmachine_government;
11370 
11371 
11372 
11373 
11374 
11375  i = government_distribute_unemployment_benefits();
11376 
11377 
11378 
11379  if(i == 1)
11380  {
11381  free_government_agent(current_xmachine_government_holder, government_GovernmentUnemploymentBenefits_state);
11382  }
11383  else
11384  {
11385  transition_government_agent(current_xmachine_government_holder, government_GovernmentUnemploymentBenefits_state, government_GovernmentLabourTax_state);
11386  }
11387 
11388 
11389  current_xmachine_government = NULL;
11390 
11391  current_xmachine_government_holder = temp_xmachine_government_holder;
11392  }
11393  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_distribute_unemployment_benefits\n");
11394 
11395  if(FLAME_unemployment_benefit_message_board_write == 1)
11396  {
11397 
11398  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_unemployment_benefit)\n");
11399  rc = MB_SyncStart(b_unemployment_benefit);
11400  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_unemployment_benefit)\n");
11401  #ifdef ERRCHECK
11402  if (rc != MB_SUCCESS)
11403  {
11404  fprintf(stderr, "ERROR: Could not start sync of 'unemployment_benefit' board\n");
11405  switch(rc) {
11406  case MB_ERR_INVALID:
11407  fprintf(stderr, "\t reason: 'unemployment_benefit' board is invalid\n");
11408  break;
11409  case MB_ERR_LOCKED:
11410  fprintf(stderr, "\t reason: 'unemployment_benefit' board is locked\n");
11411  break;
11412  case MB_ERR_MEMALLOC:
11413  fprintf(stderr, "\t reason: out of memory\n");
11414  break;
11415  case MB_ERR_INTERNAL:
11416  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11417  break;
11418  default:
11419  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
11420  break;
11421  }
11422 
11423 
11424  exit(rc);
11425  }
11426  #endif
11427  }
11428 
11429 
11430 
11431  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_credit_insolvency_bankruptcy\n");
11432  current_xmachine_firm_holder = firm_FirmCreditInsolvencyCheck_state->agents;
11433  while(current_xmachine_firm_holder)
11434  {
11435  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
11436  current_xmachine_firm = current_xmachine_firm_holder->agent;
11437  current_xmachine_firm_next_state = firm_FirmProductionStart_state;
11438  /* For backwards compatibility set current_xmachine */
11439  current_xmachine->xmachine_firm = NULL;
11440  current_xmachine->xmachine_household = NULL;
11441  current_xmachine->xmachine_equityfund = NULL;
11442  current_xmachine->xmachine_bank = NULL;
11443  current_xmachine->xmachine_government = NULL;
11444  current_xmachine->xmachine_centralbank = NULL;
11445  current_xmachine->xmachine_jpoffice = NULL;
11446  current_xmachine->xmachine_mall = NULL;
11447  current_xmachine->xmachine_reagency = NULL;
11448  current_xmachine->xmachine_firm = current_xmachine_firm;
11449 
11450  if(FLAME_condition_firm_firm_credit_insolvency_bankruptcy_FirmCreditInsolvencyCheck_FirmProductionStart(current_xmachine_firm)==1)
11451  {
11452 
11453 
11454 
11455  i = firm_credit_insolvency_bankruptcy();
11456 
11457 
11458 
11459  if(i == 1)
11460  {
11461  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditInsolvencyCheck_state);
11462  }
11463  else
11464  {
11465  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditInsolvencyCheck_state, firm_FirmProductionStart_state);
11466  }
11467  }
11468 
11469  current_xmachine_firm = NULL;
11470 
11471  current_xmachine_firm_holder = temp_xmachine_firm_holder;
11472  }
11473  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_credit_insolvency_bankruptcy\n");
11474 
11475  if(FLAME_loan_writeoff_message_board_write == 1)
11476  {
11477 
11478  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_loan_writeoff)\n");
11479  rc = MB_SyncStart(b_loan_writeoff);
11480  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_loan_writeoff)\n");
11481  #ifdef ERRCHECK
11482  if (rc != MB_SUCCESS)
11483  {
11484  fprintf(stderr, "ERROR: Could not start sync of 'loan_writeoff' board\n");
11485  switch(rc) {
11486  case MB_ERR_INVALID:
11487  fprintf(stderr, "\t reason: 'loan_writeoff' board is invalid\n");
11488  break;
11489  case MB_ERR_LOCKED:
11490  fprintf(stderr, "\t reason: 'loan_writeoff' board is locked\n");
11491  break;
11492  case MB_ERR_MEMALLOC:
11493  fprintf(stderr, "\t reason: out of memory\n");
11494  break;
11495  case MB_ERR_INTERNAL:
11496  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11497  break;
11498  default:
11499  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
11500  break;
11501  }
11502 
11503 
11504  exit(rc);
11505  }
11506  #endif
11507  }
11508 
11509 
11510  if(FLAME_new_entrant_loan_message_board_write == 1)
11511  {
11512 
11513  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_new_entrant_loan)\n");
11514  rc = MB_SyncStart(b_new_entrant_loan);
11515  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_new_entrant_loan)\n");
11516  #ifdef ERRCHECK
11517  if (rc != MB_SUCCESS)
11518  {
11519  fprintf(stderr, "ERROR: Could not start sync of 'new_entrant_loan' board\n");
11520  switch(rc) {
11521  case MB_ERR_INVALID:
11522  fprintf(stderr, "\t reason: 'new_entrant_loan' board is invalid\n");
11523  break;
11524  case MB_ERR_LOCKED:
11525  fprintf(stderr, "\t reason: 'new_entrant_loan' board is locked\n");
11526  break;
11527  case MB_ERR_MEMALLOC:
11528  fprintf(stderr, "\t reason: out of memory\n");
11529  break;
11530  case MB_ERR_INTERNAL:
11531  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11532  break;
11533  default:
11534  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
11535  break;
11536  }
11537 
11538 
11539  exit(rc);
11540  }
11541  #endif
11542  }
11543 
11544 
11545 
11546  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
11547  current_xmachine_equityfund_holder = equityfund_EFLabourMarket_state->agents;
11548  while(current_xmachine_equityfund_holder)
11549  {
11550  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
11551  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
11552  current_xmachine_equityfund_next_state = equityfund_end_state;
11553  /* For backwards compatibility set current_xmachine */
11554  current_xmachine->xmachine_firm = NULL;
11555  current_xmachine->xmachine_household = NULL;
11556  current_xmachine->xmachine_equityfund = NULL;
11557  current_xmachine->xmachine_bank = NULL;
11558  current_xmachine->xmachine_government = NULL;
11559  current_xmachine->xmachine_centralbank = NULL;
11560  current_xmachine->xmachine_jpoffice = NULL;
11561  current_xmachine->xmachine_mall = NULL;
11562  current_xmachine->xmachine_reagency = NULL;
11563  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
11564 
11565  if(FLAME_condition_equityfund_idle_EFLabourMarket_end(current_xmachine_equityfund)==1)
11566  {
11567 
11568 
11569 
11570  i = idle();
11571 
11572 
11573 
11574  if(i == 1)
11575  {
11576  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFLabourMarket_state);
11577  }
11578  else
11579  {
11580  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFLabourMarket_state, equityfund_end_state);
11581  }
11582  }
11583 
11584  current_xmachine_equityfund = NULL;
11585 
11586  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
11587  }
11588  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
11589 
11590 
11591  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
11592  current_xmachine_household_holder = household_HHCreditMonthly_state->agents;
11593  while(current_xmachine_household_holder)
11594  {
11595  temp_xmachine_household_holder = current_xmachine_household_holder->next;
11596  current_xmachine_household = current_xmachine_household_holder->agent;
11597  current_xmachine_household_next_state = household_HHLabourStart_state;
11598  /* For backwards compatibility set current_xmachine */
11599  current_xmachine->xmachine_firm = NULL;
11600  current_xmachine->xmachine_household = NULL;
11601  current_xmachine->xmachine_equityfund = NULL;
11602  current_xmachine->xmachine_bank = NULL;
11603  current_xmachine->xmachine_government = NULL;
11604  current_xmachine->xmachine_centralbank = NULL;
11605  current_xmachine->xmachine_jpoffice = NULL;
11606  current_xmachine->xmachine_mall = NULL;
11607  current_xmachine->xmachine_reagency = NULL;
11608  current_xmachine->xmachine_household = current_xmachine_household;
11609 
11610  if(FLAME_condition_household_idle_HHCreditMonthly_HHLabourStart(current_xmachine_household)==1)
11611  {
11612 
11613 
11614 
11615  i = idle();
11616 
11617 
11618 
11619  if(i == 1)
11620  {
11621  free_household_agent(current_xmachine_household_holder, household_HHCreditMonthly_state);
11622  }
11623  else
11624  {
11625  transition_household_agent(current_xmachine_household_holder, household_HHCreditMonthly_state, household_HHLabourStart_state);
11626  }
11627  }
11628 
11629  current_xmachine_household = NULL;
11630 
11631  current_xmachine_household_holder = temp_xmachine_household_holder;
11632  }
11633  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
11634 
11635 
11636  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
11637  current_xmachine_firm_holder = firm_FirmCreditInsolvencyCheck_state->agents;
11638  while(current_xmachine_firm_holder)
11639  {
11640  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
11641  current_xmachine_firm = current_xmachine_firm_holder->agent;
11642  current_xmachine_firm_next_state = firm_FirmProductionStart_state;
11643  /* For backwards compatibility set current_xmachine */
11644  current_xmachine->xmachine_firm = NULL;
11645  current_xmachine->xmachine_household = NULL;
11646  current_xmachine->xmachine_equityfund = NULL;
11647  current_xmachine->xmachine_bank = NULL;
11648  current_xmachine->xmachine_government = NULL;
11649  current_xmachine->xmachine_centralbank = NULL;
11650  current_xmachine->xmachine_jpoffice = NULL;
11651  current_xmachine->xmachine_mall = NULL;
11652  current_xmachine->xmachine_reagency = NULL;
11653  current_xmachine->xmachine_firm = current_xmachine_firm;
11654 
11655  if(FLAME_condition_firm_idle_FirmCreditInsolvencyCheck_FirmProductionStart(current_xmachine_firm)==1)
11656  {
11657 
11658 
11659 
11660  i = idle();
11661 
11662 
11663 
11664  if(i == 1)
11665  {
11666  free_firm_agent(current_xmachine_firm_holder, firm_FirmCreditInsolvencyCheck_state);
11667  }
11668  else
11669  {
11670  transition_firm_agent(current_xmachine_firm_holder, firm_FirmCreditInsolvencyCheck_state, firm_FirmProductionStart_state);
11671  }
11672  }
11673 
11674  current_xmachine_firm = NULL;
11675 
11676  current_xmachine_firm_holder = temp_xmachine_firm_holder;
11677  }
11678  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
11679 
11680 
11681  /* If mb is not read then leave sync complete until last possible moment */
11682  if(FLAME_general_benefit_message_board_read == 1)
11683  {
11684  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_general_benefit)\n");
11685  rc = MB_SyncComplete(b_general_benefit);
11686  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_general_benefit)\n");
11687  #ifdef ERRCHECK
11688  if (rc != MB_SUCCESS)
11689  {
11690  fprintf(stderr, "ERROR: Could not complete sync of 'general_benefit' board\n");
11691  switch(rc) {
11692  case MB_ERR_INVALID:
11693  fprintf(stderr, "\t reason: 'general_benefit' board is invalid\n");
11694  break;
11695  case MB_ERR_MEMALLOC:
11696  fprintf(stderr, "\t reason: out of memory\n");
11697  break;
11698  case MB_ERR_INTERNAL:
11699  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11700  break;
11701  default:
11702  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
11703  break;
11704  }
11705 
11706 
11707  exit(rc);
11708  }
11709  #endif
11710 
11711 
11712 
11713  }
11714 
11715  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_credit_collect_benefits\n");
11716  current_xmachine_household_holder = household_HHCreditMonthly_state->agents;
11717  while(current_xmachine_household_holder)
11718  {
11719  temp_xmachine_household_holder = current_xmachine_household_holder->next;
11720  current_xmachine_household = current_xmachine_household_holder->agent;
11721  current_xmachine_household_next_state = household_HHCreditEmployment_state;
11722  /* For backwards compatibility set current_xmachine */
11723  current_xmachine->xmachine_firm = NULL;
11724  current_xmachine->xmachine_household = NULL;
11725  current_xmachine->xmachine_equityfund = NULL;
11726  current_xmachine->xmachine_bank = NULL;
11727  current_xmachine->xmachine_government = NULL;
11728  current_xmachine->xmachine_centralbank = NULL;
11729  current_xmachine->xmachine_jpoffice = NULL;
11730  current_xmachine->xmachine_mall = NULL;
11731  current_xmachine->xmachine_reagency = NULL;
11732  current_xmachine->xmachine_household = current_xmachine_household;
11733 
11734  if(FLAME_condition_household_household_credit_collect_benefits_HHCreditMonthly_HHCreditEmployment(current_xmachine_household)==1)
11735  {
11736 
11737 
11738 
11739 
11740  rc = MB_Iterator_Create(b_general_benefit, &i_general_benefit);
11741 
11742 
11743  #ifdef ERRCHECK
11744  if (rc != MB_SUCCESS)
11745  {
11746  fprintf(stderr, "ERROR: Could not create Iterator for 'general_benefit'\n");
11747  switch(rc) {
11748  case MB_ERR_INVALID:
11749  fprintf(stderr, "\t reason: 'general_benefit' board is invalid\n");
11750  break;
11751  case MB_ERR_LOCKED:
11752  fprintf(stderr, "\t reason: 'general_benefit' board is locked\n");
11753  break;
11754  case MB_ERR_MEMALLOC:
11755  fprintf(stderr, "\t reason: out of memory\n");
11756  break;
11757  case MB_ERR_INTERNAL:
11758  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11759  break;
11760  default:
11761 
11762 
11763  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
11764 
11765  break;
11766  }
11767 
11768 
11769  exit(rc);
11770  }
11771  #endif
11772 
11773 
11774 
11775  i = household_credit_collect_benefits();
11776 
11777 
11778  rc = MB_Iterator_Delete(&i_general_benefit);
11779  #ifdef ERRCHECK
11780  if (rc != MB_SUCCESS)
11781  {
11782  fprintf(stderr, "ERROR: Could not delete 'general_benefit' iterator\n");
11783  switch(rc) {
11784  case MB_ERR_INVALID:
11785  fprintf(stderr, "\t reason: 'general_benefit' iterator is invalid\n");
11786  break;
11787  case MB_ERR_INTERNAL:
11788  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11789  break;
11790  default:
11791  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
11792  break;
11793  }
11794 
11795 
11796  exit(rc);
11797  }
11798  #endif
11799 
11800 
11801  if(i == 1)
11802  {
11803  free_household_agent(current_xmachine_household_holder, household_HHCreditMonthly_state);
11804  }
11805  else
11806  {
11807  transition_household_agent(current_xmachine_household_holder, household_HHCreditMonthly_state, household_HHCreditEmployment_state);
11808  }
11809  }
11810 
11811  current_xmachine_household = NULL;
11812 
11813  current_xmachine_household_holder = temp_xmachine_household_holder;
11814  }
11815  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_credit_collect_benefits\n");
11816 
11817 
11818 /* End of layer number 19 */
11819 
11820 /* Clear message boards that have finished being used
11821  * and sync complete if doing late sync complete */
11822 
11823 if(FLAME_general_benefit_message_board_read == 0)
11824 {
11825  /*printf("%d> general_benefit message board sync complete late as no agents reading any messages of this type\n", node_number);*/
11826 
11827  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_general_benefit)\n");
11828  rc = MB_SyncComplete(b_general_benefit);
11829  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_general_benefit)\n");
11830  #ifdef ERRCHECK
11831  if (rc != MB_SUCCESS)
11832  {
11833  fprintf(stderr, "ERROR: Could not complete sync of 'general_benefit' board\n");
11834  switch(rc) {
11835  case MB_ERR_INVALID:
11836  fprintf(stderr, "\t reason: 'general_benefit' board is invalid\n");
11837  break;
11838  case MB_ERR_MEMALLOC:
11839  fprintf(stderr, "\t reason: out of memory\n");
11840  break;
11841  case MB_ERR_INTERNAL:
11842  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11843  break;
11844  default:
11845  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
11846  break;
11847  }
11848 
11849 
11850  exit(rc);
11851  }
11852  #endif
11853 }
11854 
11855  /* Delete any search trees */
11856 
11857  rc = MB_Clear(b_general_benefit);
11858  #ifdef ERRCHECK
11859  if (rc != MB_SUCCESS)
11860  {
11861  fprintf(stderr, "ERROR: Could not clear 'general_benefit' board\n");
11862  switch(rc) {
11863  case MB_ERR_INVALID:
11864  fprintf(stderr, "\t reason: 'general_benefit' board is invalid\n");
11865  break;
11866  case MB_ERR_LOCKED:
11867  fprintf(stderr, "\t reason: 'general_benefit' board is locked\n");
11868  break;
11869  case MB_ERR_INTERNAL:
11870  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
11871  break;
11872  default:
11873  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
11874  break;
11875 
11876  }
11877 
11878 
11879  exit(rc);
11880  }
11881  #endif
11882 
11883  /* DEBUG: States with branching functions */
11884  current_xmachine_household_holder = household_HHCreditEmployment_state->agents;
11885  while(current_xmachine_household_holder)
11886  {
11887  FLAME_debug_count = 0;
11888  /* Function: idle */
11889  if(FLAME_condition_household_idle_HHCreditEmployment_HHLabourStart(current_xmachine_household_holder->agent)==1)
11890  { FLAME_debug_count++; }
11891  /* Function: household_credit_collect_unemployment */
11892  if(FLAME_condition_household_household_credit_collect_unemployment_HHCreditEmployment_HHLabourStart(current_xmachine_household_holder->agent)==1)
11893  { FLAME_debug_count++; }
11894  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
11895  if(FLAME_debug_count != 1)
11896  {
11897  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHCreditEmployment'\n");
11898  if(FLAME_debug_count > 1)
11899  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
11900  if(FLAME_debug_count == 0)
11901  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
11902  }
11903 
11904  current_xmachine_household_holder = current_xmachine_household_holder->next;
11905  }
11906 
11907  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
11908  current_xmachine_household_holder = household_HHCreditEmployment_state->agents;
11909  while(current_xmachine_household_holder)
11910  {
11911  temp_xmachine_household_holder = current_xmachine_household_holder->next;
11912  current_xmachine_household = current_xmachine_household_holder->agent;
11913  current_xmachine_household_next_state = household_HHLabourStart_state;
11914  /* For backwards compatibility set current_xmachine */
11915  current_xmachine->xmachine_firm = NULL;
11916  current_xmachine->xmachine_household = NULL;
11917  current_xmachine->xmachine_equityfund = NULL;
11918  current_xmachine->xmachine_bank = NULL;
11919  current_xmachine->xmachine_government = NULL;
11920  current_xmachine->xmachine_centralbank = NULL;
11921  current_xmachine->xmachine_jpoffice = NULL;
11922  current_xmachine->xmachine_mall = NULL;
11923  current_xmachine->xmachine_reagency = NULL;
11924  current_xmachine->xmachine_household = current_xmachine_household;
11925 
11926  if(FLAME_condition_household_idle_HHCreditEmployment_HHLabourStart(current_xmachine_household)==1)
11927  {
11928 
11929 
11930 
11931  i = idle();
11932 
11933 
11934 
11935  if(i == 1)
11936  {
11937  free_household_agent(current_xmachine_household_holder, household_HHCreditEmployment_state);
11938  }
11939  else
11940  {
11941  transition_household_agent(current_xmachine_household_holder, household_HHCreditEmployment_state, household_HHLabourStart_state);
11942  }
11943  }
11944 
11945  current_xmachine_household = NULL;
11946 
11947  current_xmachine_household_holder = temp_xmachine_household_holder;
11948  }
11949  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
11950 
11951 
11952  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
11953  current_xmachine_firm_holder = firm_FirmProductionStart_state->agents;
11954  while(current_xmachine_firm_holder)
11955  {
11956  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
11957  current_xmachine_firm = current_xmachine_firm_holder->agent;
11958  current_xmachine_firm_next_state = firm_FirmProductionSkip_state;
11959  /* For backwards compatibility set current_xmachine */
11960  current_xmachine->xmachine_firm = NULL;
11961  current_xmachine->xmachine_household = NULL;
11962  current_xmachine->xmachine_equityfund = NULL;
11963  current_xmachine->xmachine_bank = NULL;
11964  current_xmachine->xmachine_government = NULL;
11965  current_xmachine->xmachine_centralbank = NULL;
11966  current_xmachine->xmachine_jpoffice = NULL;
11967  current_xmachine->xmachine_mall = NULL;
11968  current_xmachine->xmachine_reagency = NULL;
11969  current_xmachine->xmachine_firm = current_xmachine_firm;
11970 
11971  if(FLAME_condition_firm_idle_FirmProductionStart_FirmProductionSkip(current_xmachine_firm)==1)
11972  {
11973 
11974 
11975 
11976  i = idle();
11977 
11978 
11979 
11980  if(i == 1)
11981  {
11982  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionStart_state);
11983  }
11984  else
11985  {
11986  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionStart_state, firm_FirmProductionSkip_state);
11987  }
11988  }
11989 
11990  current_xmachine_firm = NULL;
11991 
11992  current_xmachine_firm_holder = temp_xmachine_firm_holder;
11993  }
11994  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
11995 
11996 
11997  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
11998  current_xmachine_firm_holder = firm_FirmProductionStart_state->agents;
11999  while(current_xmachine_firm_holder)
12000  {
12001  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
12002  current_xmachine_firm = current_xmachine_firm_holder->agent;
12003  current_xmachine_firm_next_state = firm_FirmLabourStart_state;
12004  /* For backwards compatibility set current_xmachine */
12005  current_xmachine->xmachine_firm = NULL;
12006  current_xmachine->xmachine_household = NULL;
12007  current_xmachine->xmachine_equityfund = NULL;
12008  current_xmachine->xmachine_bank = NULL;
12009  current_xmachine->xmachine_government = NULL;
12010  current_xmachine->xmachine_centralbank = NULL;
12011  current_xmachine->xmachine_jpoffice = NULL;
12012  current_xmachine->xmachine_mall = NULL;
12013  current_xmachine->xmachine_reagency = NULL;
12014  current_xmachine->xmachine_firm = current_xmachine_firm;
12015 
12016  if(FLAME_condition_firm_idle_FirmProductionStart_FirmLabourStart(current_xmachine_firm)==1)
12017  {
12018 
12019 
12020 
12021  i = idle();
12022 
12023 
12024 
12025  if(i == 1)
12026  {
12027  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionStart_state);
12028  }
12029  else
12030  {
12031  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionStart_state, firm_FirmLabourStart_state);
12032  }
12033  }
12034 
12035  current_xmachine_firm = NULL;
12036 
12037  current_xmachine_firm_holder = temp_xmachine_firm_holder;
12038  }
12039  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
12040 
12041 
12042  /* If mb is not read then leave sync complete until last possible moment */
12043  if(FLAME_unemployment_benefit_message_board_read == 1)
12044  {
12045  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_unemployment_benefit)\n");
12046  rc = MB_SyncComplete(b_unemployment_benefit);
12047  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_unemployment_benefit)\n");
12048  #ifdef ERRCHECK
12049  if (rc != MB_SUCCESS)
12050  {
12051  fprintf(stderr, "ERROR: Could not complete sync of 'unemployment_benefit' board\n");
12052  switch(rc) {
12053  case MB_ERR_INVALID:
12054  fprintf(stderr, "\t reason: 'unemployment_benefit' board is invalid\n");
12055  break;
12056  case MB_ERR_MEMALLOC:
12057  fprintf(stderr, "\t reason: out of memory\n");
12058  break;
12059  case MB_ERR_INTERNAL:
12060  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12061  break;
12062  default:
12063  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
12064  break;
12065  }
12066 
12067 
12068  exit(rc);
12069  }
12070  #endif
12071 
12072 
12073 
12074  }
12075 
12076  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_credit_collect_unemployment\n");
12077  current_xmachine_household_holder = household_HHCreditEmployment_state->agents;
12078  while(current_xmachine_household_holder)
12079  {
12080  temp_xmachine_household_holder = current_xmachine_household_holder->next;
12081  current_xmachine_household = current_xmachine_household_holder->agent;
12082  current_xmachine_household_next_state = household_HHLabourStart_state;
12083  /* For backwards compatibility set current_xmachine */
12084  current_xmachine->xmachine_firm = NULL;
12085  current_xmachine->xmachine_household = NULL;
12086  current_xmachine->xmachine_equityfund = NULL;
12087  current_xmachine->xmachine_bank = NULL;
12088  current_xmachine->xmachine_government = NULL;
12089  current_xmachine->xmachine_centralbank = NULL;
12090  current_xmachine->xmachine_jpoffice = NULL;
12091  current_xmachine->xmachine_mall = NULL;
12092  current_xmachine->xmachine_reagency = NULL;
12093  current_xmachine->xmachine_household = current_xmachine_household;
12094 
12095  if(FLAME_condition_household_household_credit_collect_unemployment_HHCreditEmployment_HHLabourStart(current_xmachine_household)==1)
12096  {
12097 
12098 
12099 
12100 
12101  rc = MB_Iterator_Create(b_unemployment_benefit, &i_unemployment_benefit);
12102 
12103 
12104  #ifdef ERRCHECK
12105  if (rc != MB_SUCCESS)
12106  {
12107  fprintf(stderr, "ERROR: Could not create Iterator for 'unemployment_benefit'\n");
12108  switch(rc) {
12109  case MB_ERR_INVALID:
12110  fprintf(stderr, "\t reason: 'unemployment_benefit' board is invalid\n");
12111  break;
12112  case MB_ERR_LOCKED:
12113  fprintf(stderr, "\t reason: 'unemployment_benefit' board is locked\n");
12114  break;
12115  case MB_ERR_MEMALLOC:
12116  fprintf(stderr, "\t reason: out of memory\n");
12117  break;
12118  case MB_ERR_INTERNAL:
12119  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12120  break;
12121  default:
12122 
12123 
12124  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
12125 
12126  break;
12127  }
12128 
12129 
12130  exit(rc);
12131  }
12132  #endif
12133 
12134 
12135 
12136  i = household_credit_collect_unemployment();
12137 
12138 
12139  rc = MB_Iterator_Delete(&i_unemployment_benefit);
12140  #ifdef ERRCHECK
12141  if (rc != MB_SUCCESS)
12142  {
12143  fprintf(stderr, "ERROR: Could not delete 'unemployment_benefit' iterator\n");
12144  switch(rc) {
12145  case MB_ERR_INVALID:
12146  fprintf(stderr, "\t reason: 'unemployment_benefit' iterator is invalid\n");
12147  break;
12148  case MB_ERR_INTERNAL:
12149  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12150  break;
12151  default:
12152  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
12153  break;
12154  }
12155 
12156 
12157  exit(rc);
12158  }
12159  #endif
12160 
12161 
12162  if(i == 1)
12163  {
12164  free_household_agent(current_xmachine_household_holder, household_HHCreditEmployment_state);
12165  }
12166  else
12167  {
12168  transition_household_agent(current_xmachine_household_holder, household_HHCreditEmployment_state, household_HHLabourStart_state);
12169  }
12170  }
12171 
12172  current_xmachine_household = NULL;
12173 
12174  current_xmachine_household_holder = temp_xmachine_household_holder;
12175  }
12176  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_credit_collect_unemployment\n");
12177 
12178 
12179  /* If mb is not read then leave sync complete until last possible moment */
12180  if(FLAME_loan_writeoff_message_board_read == 1)
12181  {
12182  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_writeoff)\n");
12183  rc = MB_SyncComplete(b_loan_writeoff);
12184  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_writeoff)\n");
12185  #ifdef ERRCHECK
12186  if (rc != MB_SUCCESS)
12187  {
12188  fprintf(stderr, "ERROR: Could not complete sync of 'loan_writeoff' board\n");
12189  switch(rc) {
12190  case MB_ERR_INVALID:
12191  fprintf(stderr, "\t reason: 'loan_writeoff' board is invalid\n");
12192  break;
12193  case MB_ERR_MEMALLOC:
12194  fprintf(stderr, "\t reason: out of memory\n");
12195  break;
12196  case MB_ERR_INTERNAL:
12197  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12198  break;
12199  default:
12200  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
12201  break;
12202  }
12203 
12204 
12205  exit(rc);
12206  }
12207  #endif
12208 
12209 
12210 
12211  }
12212 
12213  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_recieve_loan_writeoffs\n");
12214  current_xmachine_bank_holder = bank_BankCreditLoanWriteOffs_state->agents;
12215  while(current_xmachine_bank_holder)
12216  {
12217  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
12218  current_xmachine_bank = current_xmachine_bank_holder->agent;
12219  current_xmachine_bank_next_state = bank_BankCreditNewEntrants_state;
12220  /* For backwards compatibility set current_xmachine */
12221  current_xmachine->xmachine_firm = NULL;
12222  current_xmachine->xmachine_household = NULL;
12223  current_xmachine->xmachine_equityfund = NULL;
12224  current_xmachine->xmachine_bank = NULL;
12225  current_xmachine->xmachine_government = NULL;
12226  current_xmachine->xmachine_centralbank = NULL;
12227  current_xmachine->xmachine_jpoffice = NULL;
12228  current_xmachine->xmachine_mall = NULL;
12229  current_xmachine->xmachine_reagency = NULL;
12230  current_xmachine->xmachine_bank = current_xmachine_bank;
12231 
12232 
12233 
12234 
12235 
12236 
12237 
12238 
12239  rc = MB_Iterator_CreateFiltered(b_loan_writeoff, &i_loan_writeoff, &FLAME_filter_bank_bank_credit_recieve_loan_writeoffs_BankCreditLoanWriteOffs_BankCreditNewEntrants_loan_writeoff, current_xmachine_bank);
12240 
12241 
12242 
12243  #ifdef ERRCHECK
12244  if (rc != MB_SUCCESS)
12245  {
12246  fprintf(stderr, "ERROR: Could not create Iterator for 'loan_writeoff'\n");
12247  switch(rc) {
12248  case MB_ERR_INVALID:
12249  fprintf(stderr, "\t reason: 'loan_writeoff' board is invalid\n");
12250  break;
12251  case MB_ERR_LOCKED:
12252  fprintf(stderr, "\t reason: 'loan_writeoff' board is locked\n");
12253  break;
12254  case MB_ERR_MEMALLOC:
12255  fprintf(stderr, "\t reason: out of memory\n");
12256  break;
12257  case MB_ERR_INTERNAL:
12258  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12259  break;
12260  default:
12261 
12262  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
12263 
12264 
12265  break;
12266  }
12267 
12268 
12269  exit(rc);
12270  }
12271  #endif
12272 
12273 
12274 
12275  i = bank_credit_recieve_loan_writeoffs();
12276 
12277 
12278  rc = MB_Iterator_Delete(&i_loan_writeoff);
12279  #ifdef ERRCHECK
12280  if (rc != MB_SUCCESS)
12281  {
12282  fprintf(stderr, "ERROR: Could not delete 'loan_writeoff' iterator\n");
12283  switch(rc) {
12284  case MB_ERR_INVALID:
12285  fprintf(stderr, "\t reason: 'loan_writeoff' iterator is invalid\n");
12286  break;
12287  case MB_ERR_INTERNAL:
12288  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12289  break;
12290  default:
12291  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
12292  break;
12293  }
12294 
12295 
12296  exit(rc);
12297  }
12298  #endif
12299 
12300 
12301  if(i == 1)
12302  {
12303  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditLoanWriteOffs_state);
12304  }
12305  else
12306  {
12307  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditLoanWriteOffs_state, bank_BankCreditNewEntrants_state);
12308  }
12309 
12310 
12311  current_xmachine_bank = NULL;
12312 
12313  current_xmachine_bank_holder = temp_xmachine_bank_holder;
12314  }
12315  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_recieve_loan_writeoffs\n");
12316 
12317 
12318 /* End of layer number 20 */
12319 
12320 /* Clear message boards that have finished being used
12321  * and sync complete if doing late sync complete */
12322 
12323 if(FLAME_unemployment_benefit_message_board_read == 0)
12324 {
12325  /*printf("%d> unemployment_benefit message board sync complete late as no agents reading any messages of this type\n", node_number);*/
12326 
12327  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_unemployment_benefit)\n");
12328  rc = MB_SyncComplete(b_unemployment_benefit);
12329  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_unemployment_benefit)\n");
12330  #ifdef ERRCHECK
12331  if (rc != MB_SUCCESS)
12332  {
12333  fprintf(stderr, "ERROR: Could not complete sync of 'unemployment_benefit' board\n");
12334  switch(rc) {
12335  case MB_ERR_INVALID:
12336  fprintf(stderr, "\t reason: 'unemployment_benefit' board is invalid\n");
12337  break;
12338  case MB_ERR_MEMALLOC:
12339  fprintf(stderr, "\t reason: out of memory\n");
12340  break;
12341  case MB_ERR_INTERNAL:
12342  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12343  break;
12344  default:
12345  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
12346  break;
12347  }
12348 
12349 
12350  exit(rc);
12351  }
12352  #endif
12353 }
12354 
12355  /* Delete any search trees */
12356 
12357  rc = MB_Clear(b_unemployment_benefit);
12358  #ifdef ERRCHECK
12359  if (rc != MB_SUCCESS)
12360  {
12361  fprintf(stderr, "ERROR: Could not clear 'unemployment_benefit' board\n");
12362  switch(rc) {
12363  case MB_ERR_INVALID:
12364  fprintf(stderr, "\t reason: 'unemployment_benefit' board is invalid\n");
12365  break;
12366  case MB_ERR_LOCKED:
12367  fprintf(stderr, "\t reason: 'unemployment_benefit' board is locked\n");
12368  break;
12369  case MB_ERR_INTERNAL:
12370  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12371  break;
12372  default:
12373  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
12374  break;
12375 
12376  }
12377 
12378 
12379  exit(rc);
12380  }
12381  #endif
12382 
12383 if(FLAME_loan_writeoff_message_board_read == 0)
12384 {
12385  /*printf("%d> loan_writeoff message board sync complete late as no agents reading any messages of this type\n", node_number);*/
12386 
12387  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_loan_writeoff)\n");
12388  rc = MB_SyncComplete(b_loan_writeoff);
12389  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_loan_writeoff)\n");
12390  #ifdef ERRCHECK
12391  if (rc != MB_SUCCESS)
12392  {
12393  fprintf(stderr, "ERROR: Could not complete sync of 'loan_writeoff' board\n");
12394  switch(rc) {
12395  case MB_ERR_INVALID:
12396  fprintf(stderr, "\t reason: 'loan_writeoff' board is invalid\n");
12397  break;
12398  case MB_ERR_MEMALLOC:
12399  fprintf(stderr, "\t reason: out of memory\n");
12400  break;
12401  case MB_ERR_INTERNAL:
12402  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12403  break;
12404  default:
12405  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
12406  break;
12407  }
12408 
12409 
12410  exit(rc);
12411  }
12412  #endif
12413 }
12414 
12415  /* Delete any search trees */
12416 
12417  rc = MB_Clear(b_loan_writeoff);
12418  #ifdef ERRCHECK
12419  if (rc != MB_SUCCESS)
12420  {
12421  fprintf(stderr, "ERROR: Could not clear 'loan_writeoff' board\n");
12422  switch(rc) {
12423  case MB_ERR_INVALID:
12424  fprintf(stderr, "\t reason: 'loan_writeoff' board is invalid\n");
12425  break;
12426  case MB_ERR_LOCKED:
12427  fprintf(stderr, "\t reason: 'loan_writeoff' board is locked\n");
12428  break;
12429  case MB_ERR_INTERNAL:
12430  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12431  break;
12432  default:
12433  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
12434  break;
12435 
12436  }
12437 
12438 
12439  exit(rc);
12440  }
12441  #endif
12442 
12443  /* DEBUG: States with branching functions */
12444  current_xmachine_firm_holder = firm_FirmProductionSkip_state->agents;
12445  while(current_xmachine_firm_holder)
12446  {
12447  FLAME_debug_count = 0;
12448  /* Function: idle */
12449  if(FLAME_condition_firm_idle_FirmProductionSkip_FirmProductionRoleCheck(current_xmachine_firm_holder->agent)==1)
12450  { FLAME_debug_count++; }
12451  /* Function: firm_production_skip */
12452  if(FLAME_condition_firm_firm_production_skip_FirmProductionSkip_FirmLabourStart(current_xmachine_firm_holder->agent)==1)
12453  { FLAME_debug_count++; }
12454  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
12455  if(FLAME_debug_count != 1)
12456  {
12457  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmProductionSkip'\n");
12458  if(FLAME_debug_count > 1)
12459  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
12460  if(FLAME_debug_count == 0)
12461  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
12462  }
12463 
12464  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
12465  }
12466  /* DEBUG: States with branching functions */
12467  current_xmachine_household_holder = household_HHLabourStart_state->agents;
12468  while(current_xmachine_household_holder)
12469  {
12470  FLAME_debug_count = 0;
12471  /* Function: household_labour_check_fired */
12472  if(FLAME_condition_household_household_labour_check_fired_HHLabourStart_HHLabourStage1(current_xmachine_household_holder->agent)==1)
12473  { FLAME_debug_count++; }
12474  /* Function: idle */
12475  if(FLAME_condition_household_idle_HHLabourStart_HHLabourEmploymentStatus(current_xmachine_household_holder->agent)==1)
12476  { FLAME_debug_count++; }
12477  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
12478  if(FLAME_debug_count != 1)
12479  {
12480  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHLabourStart'\n");
12481  if(FLAME_debug_count > 1)
12482  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
12483  if(FLAME_debug_count == 0)
12484  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
12485  }
12486 
12487  current_xmachine_household_holder = current_xmachine_household_holder->next;
12488  }
12489 
12490  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
12491  current_xmachine_household_holder = household_HHLabourStart_state->agents;
12492  while(current_xmachine_household_holder)
12493  {
12494  temp_xmachine_household_holder = current_xmachine_household_holder->next;
12495  current_xmachine_household = current_xmachine_household_holder->agent;
12496  current_xmachine_household_next_state = household_HHLabourEmploymentStatus_state;
12497  /* For backwards compatibility set current_xmachine */
12498  current_xmachine->xmachine_firm = NULL;
12499  current_xmachine->xmachine_household = NULL;
12500  current_xmachine->xmachine_equityfund = NULL;
12501  current_xmachine->xmachine_bank = NULL;
12502  current_xmachine->xmachine_government = NULL;
12503  current_xmachine->xmachine_centralbank = NULL;
12504  current_xmachine->xmachine_jpoffice = NULL;
12505  current_xmachine->xmachine_mall = NULL;
12506  current_xmachine->xmachine_reagency = NULL;
12507  current_xmachine->xmachine_household = current_xmachine_household;
12508 
12509  if(FLAME_condition_household_idle_HHLabourStart_HHLabourEmploymentStatus(current_xmachine_household)==1)
12510  {
12511 
12512 
12513 
12514  i = idle();
12515 
12516 
12517 
12518  if(i == 1)
12519  {
12520  free_household_agent(current_xmachine_household_holder, household_HHLabourStart_state);
12521  }
12522  else
12523  {
12524  transition_household_agent(current_xmachine_household_holder, household_HHLabourStart_state, household_HHLabourEmploymentStatus_state);
12525  }
12526  }
12527 
12528  current_xmachine_household = NULL;
12529 
12530  current_xmachine_household_holder = temp_xmachine_household_holder;
12531  }
12532  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
12533 
12534 
12535  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
12536  current_xmachine_firm_holder = firm_FirmProductionSkip_state->agents;
12537  while(current_xmachine_firm_holder)
12538  {
12539  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
12540  current_xmachine_firm = current_xmachine_firm_holder->agent;
12541  current_xmachine_firm_next_state = firm_FirmProductionRoleCheck_state;
12542  /* For backwards compatibility set current_xmachine */
12543  current_xmachine->xmachine_firm = NULL;
12544  current_xmachine->xmachine_household = NULL;
12545  current_xmachine->xmachine_equityfund = NULL;
12546  current_xmachine->xmachine_bank = NULL;
12547  current_xmachine->xmachine_government = NULL;
12548  current_xmachine->xmachine_centralbank = NULL;
12549  current_xmachine->xmachine_jpoffice = NULL;
12550  current_xmachine->xmachine_mall = NULL;
12551  current_xmachine->xmachine_reagency = NULL;
12552  current_xmachine->xmachine_firm = current_xmachine_firm;
12553 
12554  if(FLAME_condition_firm_idle_FirmProductionSkip_FirmProductionRoleCheck(current_xmachine_firm)==1)
12555  {
12556 
12557 
12558 
12559  i = idle();
12560 
12561 
12562 
12563  if(i == 1)
12564  {
12565  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionSkip_state);
12566  }
12567  else
12568  {
12569  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionSkip_state, firm_FirmProductionRoleCheck_state);
12570  }
12571  }
12572 
12573  current_xmachine_firm = NULL;
12574 
12575  current_xmachine_firm_holder = temp_xmachine_firm_holder;
12576  }
12577  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
12578 
12579 
12580  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_skip\n");
12581  current_xmachine_firm_holder = firm_FirmProductionSkip_state->agents;
12582  while(current_xmachine_firm_holder)
12583  {
12584  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
12585  current_xmachine_firm = current_xmachine_firm_holder->agent;
12586  current_xmachine_firm_next_state = firm_FirmLabourStart_state;
12587  /* For backwards compatibility set current_xmachine */
12588  current_xmachine->xmachine_firm = NULL;
12589  current_xmachine->xmachine_household = NULL;
12590  current_xmachine->xmachine_equityfund = NULL;
12591  current_xmachine->xmachine_bank = NULL;
12592  current_xmachine->xmachine_government = NULL;
12593  current_xmachine->xmachine_centralbank = NULL;
12594  current_xmachine->xmachine_jpoffice = NULL;
12595  current_xmachine->xmachine_mall = NULL;
12596  current_xmachine->xmachine_reagency = NULL;
12597  current_xmachine->xmachine_firm = current_xmachine_firm;
12598 
12599  if(FLAME_condition_firm_firm_production_skip_FirmProductionSkip_FirmLabourStart(current_xmachine_firm)==1)
12600  {
12601 
12602 
12603 
12604  i = firm_production_skip();
12605 
12606 
12607 
12608  if(i == 1)
12609  {
12610  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionSkip_state);
12611  }
12612  else
12613  {
12614  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionSkip_state, firm_FirmLabourStart_state);
12615  }
12616  }
12617 
12618  current_xmachine_firm = NULL;
12619 
12620  current_xmachine_firm_holder = temp_xmachine_firm_holder;
12621  }
12622  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_skip\n");
12623 
12624 
12625  /* If mb is not read then leave sync complete until last possible moment */
12626  if(FLAME_new_entrant_loan_message_board_read == 1)
12627  {
12628  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_new_entrant_loan)\n");
12629  rc = MB_SyncComplete(b_new_entrant_loan);
12630  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_new_entrant_loan)\n");
12631  #ifdef ERRCHECK
12632  if (rc != MB_SUCCESS)
12633  {
12634  fprintf(stderr, "ERROR: Could not complete sync of 'new_entrant_loan' board\n");
12635  switch(rc) {
12636  case MB_ERR_INVALID:
12637  fprintf(stderr, "\t reason: 'new_entrant_loan' board is invalid\n");
12638  break;
12639  case MB_ERR_MEMALLOC:
12640  fprintf(stderr, "\t reason: out of memory\n");
12641  break;
12642  case MB_ERR_INTERNAL:
12643  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12644  break;
12645  default:
12646  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
12647  break;
12648  }
12649 
12650 
12651  exit(rc);
12652  }
12653  #endif
12654 
12655 
12656 
12657  }
12658 
12659  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_recieve_new_entrant_loan_requests\n");
12660  current_xmachine_bank_holder = bank_BankCreditNewEntrants_state->agents;
12661  while(current_xmachine_bank_holder)
12662  {
12663  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
12664  current_xmachine_bank = current_xmachine_bank_holder->agent;
12665  current_xmachine_bank_next_state = bank_BankCreditLoanInterests_state;
12666  /* For backwards compatibility set current_xmachine */
12667  current_xmachine->xmachine_firm = NULL;
12668  current_xmachine->xmachine_household = NULL;
12669  current_xmachine->xmachine_equityfund = NULL;
12670  current_xmachine->xmachine_bank = NULL;
12671  current_xmachine->xmachine_government = NULL;
12672  current_xmachine->xmachine_centralbank = NULL;
12673  current_xmachine->xmachine_jpoffice = NULL;
12674  current_xmachine->xmachine_mall = NULL;
12675  current_xmachine->xmachine_reagency = NULL;
12676  current_xmachine->xmachine_bank = current_xmachine_bank;
12677 
12678 
12679 
12680 
12681 
12682 
12683 
12684 
12685  rc = MB_Iterator_CreateFiltered(b_new_entrant_loan, &i_new_entrant_loan, &FLAME_filter_bank_bank_credit_recieve_new_entrant_loan_requests_BankCreditNewEntrants_BankCreditLoanInterests_new_entrant_loan, current_xmachine_bank);
12686 
12687 
12688 
12689  #ifdef ERRCHECK
12690  if (rc != MB_SUCCESS)
12691  {
12692  fprintf(stderr, "ERROR: Could not create Iterator for 'new_entrant_loan'\n");
12693  switch(rc) {
12694  case MB_ERR_INVALID:
12695  fprintf(stderr, "\t reason: 'new_entrant_loan' board is invalid\n");
12696  break;
12697  case MB_ERR_LOCKED:
12698  fprintf(stderr, "\t reason: 'new_entrant_loan' board is locked\n");
12699  break;
12700  case MB_ERR_MEMALLOC:
12701  fprintf(stderr, "\t reason: out of memory\n");
12702  break;
12703  case MB_ERR_INTERNAL:
12704  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12705  break;
12706  default:
12707 
12708  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
12709 
12710 
12711  break;
12712  }
12713 
12714 
12715  exit(rc);
12716  }
12717  #endif
12718 
12719 
12720 
12721  i = bank_credit_recieve_new_entrant_loan_requests();
12722 
12723 
12724  rc = MB_Iterator_Delete(&i_new_entrant_loan);
12725  #ifdef ERRCHECK
12726  if (rc != MB_SUCCESS)
12727  {
12728  fprintf(stderr, "ERROR: Could not delete 'new_entrant_loan' iterator\n");
12729  switch(rc) {
12730  case MB_ERR_INVALID:
12731  fprintf(stderr, "\t reason: 'new_entrant_loan' iterator is invalid\n");
12732  break;
12733  case MB_ERR_INTERNAL:
12734  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12735  break;
12736  default:
12737  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
12738  break;
12739  }
12740 
12741 
12742  exit(rc);
12743  }
12744  #endif
12745 
12746 
12747  if(i == 1)
12748  {
12749  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditNewEntrants_state);
12750  }
12751  else
12752  {
12753  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditNewEntrants_state, bank_BankCreditLoanInterests_state);
12754  }
12755 
12756 
12757  current_xmachine_bank = NULL;
12758 
12759  current_xmachine_bank_holder = temp_xmachine_bank_holder;
12760  }
12761  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_recieve_new_entrant_loan_requests\n");
12762 
12763 
12764 /* End of layer number 21 */
12765 
12766 /* Clear message boards that have finished being used
12767  * and sync complete if doing late sync complete */
12768 
12769 if(FLAME_new_entrant_loan_message_board_read == 0)
12770 {
12771  /*printf("%d> new_entrant_loan message board sync complete late as no agents reading any messages of this type\n", node_number);*/
12772 
12773  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_new_entrant_loan)\n");
12774  rc = MB_SyncComplete(b_new_entrant_loan);
12775  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_new_entrant_loan)\n");
12776  #ifdef ERRCHECK
12777  if (rc != MB_SUCCESS)
12778  {
12779  fprintf(stderr, "ERROR: Could not complete sync of 'new_entrant_loan' board\n");
12780  switch(rc) {
12781  case MB_ERR_INVALID:
12782  fprintf(stderr, "\t reason: 'new_entrant_loan' board is invalid\n");
12783  break;
12784  case MB_ERR_MEMALLOC:
12785  fprintf(stderr, "\t reason: out of memory\n");
12786  break;
12787  case MB_ERR_INTERNAL:
12788  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12789  break;
12790  default:
12791  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
12792  break;
12793  }
12794 
12795 
12796  exit(rc);
12797  }
12798  #endif
12799 }
12800 
12801  /* Delete any search trees */
12802 
12803  rc = MB_Clear(b_new_entrant_loan);
12804  #ifdef ERRCHECK
12805  if (rc != MB_SUCCESS)
12806  {
12807  fprintf(stderr, "ERROR: Could not clear 'new_entrant_loan' board\n");
12808  switch(rc) {
12809  case MB_ERR_INVALID:
12810  fprintf(stderr, "\t reason: 'new_entrant_loan' board is invalid\n");
12811  break;
12812  case MB_ERR_LOCKED:
12813  fprintf(stderr, "\t reason: 'new_entrant_loan' board is locked\n");
12814  break;
12815  case MB_ERR_INTERNAL:
12816  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12817  break;
12818  default:
12819  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
12820  break;
12821 
12822  }
12823 
12824 
12825  exit(rc);
12826  }
12827  #endif
12828 
12829 
12830  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
12831  current_xmachine_firm_holder = firm_FirmProductionRoleCheck_state->agents;
12832  while(current_xmachine_firm_holder)
12833  {
12834  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
12835  current_xmachine_firm = current_xmachine_firm_holder->agent;
12836  current_xmachine_firm_next_state = firm_FirmProductionConstructor_state;
12837  /* For backwards compatibility set current_xmachine */
12838  current_xmachine->xmachine_firm = NULL;
12839  current_xmachine->xmachine_household = NULL;
12840  current_xmachine->xmachine_equityfund = NULL;
12841  current_xmachine->xmachine_bank = NULL;
12842  current_xmachine->xmachine_government = NULL;
12843  current_xmachine->xmachine_centralbank = NULL;
12844  current_xmachine->xmachine_jpoffice = NULL;
12845  current_xmachine->xmachine_mall = NULL;
12846  current_xmachine->xmachine_reagency = NULL;
12847  current_xmachine->xmachine_firm = current_xmachine_firm;
12848 
12849  if(FLAME_condition_firm_idle_FirmProductionRoleCheck_FirmProductionConstructor(current_xmachine_firm)==1)
12850  {
12851 
12852 
12853 
12854  i = idle();
12855 
12856 
12857 
12858  if(i == 1)
12859  {
12860  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRoleCheck_state);
12861  }
12862  else
12863  {
12864  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRoleCheck_state, firm_FirmProductionConstructor_state);
12865  }
12866  }
12867 
12868  current_xmachine_firm = NULL;
12869 
12870  current_xmachine_firm_holder = temp_xmachine_firm_holder;
12871  }
12872  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
12873 
12874 
12875  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
12876  current_xmachine_firm_holder = firm_FirmProductionRoleCheck_state->agents;
12877  while(current_xmachine_firm_holder)
12878  {
12879  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
12880  current_xmachine_firm = current_xmachine_firm_holder->agent;
12881  current_xmachine_firm_next_state = firm_FirmProductionRegular_state;
12882  /* For backwards compatibility set current_xmachine */
12883  current_xmachine->xmachine_firm = NULL;
12884  current_xmachine->xmachine_household = NULL;
12885  current_xmachine->xmachine_equityfund = NULL;
12886  current_xmachine->xmachine_bank = NULL;
12887  current_xmachine->xmachine_government = NULL;
12888  current_xmachine->xmachine_centralbank = NULL;
12889  current_xmachine->xmachine_jpoffice = NULL;
12890  current_xmachine->xmachine_mall = NULL;
12891  current_xmachine->xmachine_reagency = NULL;
12892  current_xmachine->xmachine_firm = current_xmachine_firm;
12893 
12894  if(FLAME_condition_firm_idle_FirmProductionRoleCheck_FirmProductionRegular(current_xmachine_firm)==1)
12895  {
12896 
12897 
12898 
12899  i = idle();
12900 
12901 
12902 
12903  if(i == 1)
12904  {
12905  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRoleCheck_state);
12906  }
12907  else
12908  {
12909  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRoleCheck_state, firm_FirmProductionRegular_state);
12910  }
12911  }
12912 
12913  current_xmachine_firm = NULL;
12914 
12915  current_xmachine_firm_holder = temp_xmachine_firm_holder;
12916  }
12917  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
12918 
12919 
12920  /* If mb is not read then leave sync complete until last possible moment */
12921  if(FLAME_interest_on_loan_message_board_read == 1)
12922  {
12923  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_interest_on_loan)\n");
12924  rc = MB_SyncComplete(b_interest_on_loan);
12925  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_interest_on_loan)\n");
12926  #ifdef ERRCHECK
12927  if (rc != MB_SUCCESS)
12928  {
12929  fprintf(stderr, "ERROR: Could not complete sync of 'interest_on_loan' board\n");
12930  switch(rc) {
12931  case MB_ERR_INVALID:
12932  fprintf(stderr, "\t reason: 'interest_on_loan' board is invalid\n");
12933  break;
12934  case MB_ERR_MEMALLOC:
12935  fprintf(stderr, "\t reason: out of memory\n");
12936  break;
12937  case MB_ERR_INTERNAL:
12938  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
12939  break;
12940  default:
12941  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
12942  break;
12943  }
12944 
12945 
12946  exit(rc);
12947  }
12948  #endif
12949 
12950 
12951 
12952  }
12953 
12954  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_collect_loan_interests\n");
12955  current_xmachine_bank_holder = bank_BankCreditLoanInterests_state->agents;
12956  while(current_xmachine_bank_holder)
12957  {
12958  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
12959  current_xmachine_bank = current_xmachine_bank_holder->agent;
12960  current_xmachine_bank_next_state = bank_BankCreditCheckInterestRate_state;
12961  /* For backwards compatibility set current_xmachine */
12962  current_xmachine->xmachine_firm = NULL;
12963  current_xmachine->xmachine_household = NULL;
12964  current_xmachine->xmachine_equityfund = NULL;
12965  current_xmachine->xmachine_bank = NULL;
12966  current_xmachine->xmachine_government = NULL;
12967  current_xmachine->xmachine_centralbank = NULL;
12968  current_xmachine->xmachine_jpoffice = NULL;
12969  current_xmachine->xmachine_mall = NULL;
12970  current_xmachine->xmachine_reagency = NULL;
12971  current_xmachine->xmachine_bank = current_xmachine_bank;
12972 
12973 
12974 
12975 
12976 
12977 
12978 
12979 
12980  rc = MB_Iterator_CreateFiltered(b_interest_on_loan, &i_interest_on_loan, &FLAME_filter_bank_bank_credit_collect_loan_interests_BankCreditLoanInterests_BankCreditCheckInterestRate_interest_on_loan, current_xmachine_bank);
12981 
12982 
12983 
12984  #ifdef ERRCHECK
12985  if (rc != MB_SUCCESS)
12986  {
12987  fprintf(stderr, "ERROR: Could not create Iterator for 'interest_on_loan'\n");
12988  switch(rc) {
12989  case MB_ERR_INVALID:
12990  fprintf(stderr, "\t reason: 'interest_on_loan' board is invalid\n");
12991  break;
12992  case MB_ERR_LOCKED:
12993  fprintf(stderr, "\t reason: 'interest_on_loan' board is locked\n");
12994  break;
12995  case MB_ERR_MEMALLOC:
12996  fprintf(stderr, "\t reason: out of memory\n");
12997  break;
12998  case MB_ERR_INTERNAL:
12999  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13000  break;
13001  default:
13002 
13003  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
13004 
13005 
13006  break;
13007  }
13008 
13009 
13010  exit(rc);
13011  }
13012  #endif
13013 
13014 
13015 
13016  i = bank_credit_collect_loan_interests();
13017 
13018 
13019  rc = MB_Iterator_Delete(&i_interest_on_loan);
13020  #ifdef ERRCHECK
13021  if (rc != MB_SUCCESS)
13022  {
13023  fprintf(stderr, "ERROR: Could not delete 'interest_on_loan' iterator\n");
13024  switch(rc) {
13025  case MB_ERR_INVALID:
13026  fprintf(stderr, "\t reason: 'interest_on_loan' iterator is invalid\n");
13027  break;
13028  case MB_ERR_INTERNAL:
13029  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13030  break;
13031  default:
13032  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
13033  break;
13034  }
13035 
13036 
13037  exit(rc);
13038  }
13039  #endif
13040 
13041 
13042  if(i == 1)
13043  {
13044  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditLoanInterests_state);
13045  }
13046  else
13047  {
13048  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditLoanInterests_state, bank_BankCreditCheckInterestRate_state);
13049  }
13050 
13051 
13052  current_xmachine_bank = NULL;
13053 
13054  current_xmachine_bank_holder = temp_xmachine_bank_holder;
13055  }
13056  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_collect_loan_interests\n");
13057 
13058 
13059 /* End of layer number 22 */
13060 
13061 /* Clear message boards that have finished being used
13062  * and sync complete if doing late sync complete */
13063 
13064 if(FLAME_interest_on_loan_message_board_read == 0)
13065 {
13066  /*printf("%d> interest_on_loan message board sync complete late as no agents reading any messages of this type\n", node_number);*/
13067 
13068  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_interest_on_loan)\n");
13069  rc = MB_SyncComplete(b_interest_on_loan);
13070  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_interest_on_loan)\n");
13071  #ifdef ERRCHECK
13072  if (rc != MB_SUCCESS)
13073  {
13074  fprintf(stderr, "ERROR: Could not complete sync of 'interest_on_loan' board\n");
13075  switch(rc) {
13076  case MB_ERR_INVALID:
13077  fprintf(stderr, "\t reason: 'interest_on_loan' board is invalid\n");
13078  break;
13079  case MB_ERR_MEMALLOC:
13080  fprintf(stderr, "\t reason: out of memory\n");
13081  break;
13082  case MB_ERR_INTERNAL:
13083  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13084  break;
13085  default:
13086  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
13087  break;
13088  }
13089 
13090 
13091  exit(rc);
13092  }
13093  #endif
13094 }
13095 
13096  /* Delete any search trees */
13097 
13098  rc = MB_Clear(b_interest_on_loan);
13099  #ifdef ERRCHECK
13100  if (rc != MB_SUCCESS)
13101  {
13102  fprintf(stderr, "ERROR: Could not clear 'interest_on_loan' board\n");
13103  switch(rc) {
13104  case MB_ERR_INVALID:
13105  fprintf(stderr, "\t reason: 'interest_on_loan' board is invalid\n");
13106  break;
13107  case MB_ERR_LOCKED:
13108  fprintf(stderr, "\t reason: 'interest_on_loan' board is locked\n");
13109  break;
13110  case MB_ERR_INTERNAL:
13111  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13112  break;
13113  default:
13114  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
13115  break;
13116 
13117  }
13118 
13119 
13120  exit(rc);
13121  }
13122  #endif
13123 
13124  /* DEBUG: States with branching functions */
13125  current_xmachine_firm_holder = firm_FirmProductionRegular_state->agents;
13126  while(current_xmachine_firm_holder)
13127  {
13128  FLAME_debug_count = 0;
13129  /* Function: firm_production_set_price */
13130  if(FLAME_condition_firm_firm_production_set_price_FirmProductionRegular_FirmProductionPlanning(current_xmachine_firm_holder->agent)==1)
13131  { FLAME_debug_count++; }
13132  /* Function: firm_production_produce_goods */
13133  if(FLAME_condition_firm_firm_production_produce_goods_FirmProductionRegular_FirmLabourStart(current_xmachine_firm_holder->agent)==1)
13134  { FLAME_debug_count++; }
13135  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
13136  if(FLAME_debug_count != 1)
13137  {
13138  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmProductionRegular'\n");
13139  if(FLAME_debug_count > 1)
13140  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
13141  if(FLAME_debug_count == 0)
13142  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
13143  }
13144 
13145  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
13146  }
13147  /* DEBUG: States with branching functions */
13148  current_xmachine_firm_holder = firm_FirmProductionConstructor_state->agents;
13149  while(current_xmachine_firm_holder)
13150  {
13151  FLAME_debug_count = 0;
13152  /* Function: firm_production_construction_plan */
13153  if(FLAME_condition_firm_firm_production_construction_plan_FirmProductionConstructor_FirmConstructionLabourDemand(current_xmachine_firm_holder->agent)==1)
13154  { FLAME_debug_count++; }
13155  /* Function: firm_production_construct_houses */
13156  if(FLAME_condition_firm_firm_production_construct_houses_FirmProductionConstructor_FirmLabourStart(current_xmachine_firm_holder->agent)==1)
13157  { FLAME_debug_count++; }
13158  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
13159  if(FLAME_debug_count != 1)
13160  {
13161  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmProductionConstructor'\n");
13162  if(FLAME_debug_count > 1)
13163  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
13164  if(FLAME_debug_count == 0)
13165  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
13166  }
13167 
13168  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
13169  }
13170 
13171  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_construction_plan\n");
13172  current_xmachine_firm_holder = firm_FirmProductionConstructor_state->agents;
13173  while(current_xmachine_firm_holder)
13174  {
13175  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13176  current_xmachine_firm = current_xmachine_firm_holder->agent;
13177  current_xmachine_firm_next_state = firm_FirmConstructionLabourDemand_state;
13178  /* For backwards compatibility set current_xmachine */
13179  current_xmachine->xmachine_firm = NULL;
13180  current_xmachine->xmachine_household = NULL;
13181  current_xmachine->xmachine_equityfund = NULL;
13182  current_xmachine->xmachine_bank = NULL;
13183  current_xmachine->xmachine_government = NULL;
13184  current_xmachine->xmachine_centralbank = NULL;
13185  current_xmachine->xmachine_jpoffice = NULL;
13186  current_xmachine->xmachine_mall = NULL;
13187  current_xmachine->xmachine_reagency = NULL;
13188  current_xmachine->xmachine_firm = current_xmachine_firm;
13189 
13190  if(FLAME_condition_firm_firm_production_construction_plan_FirmProductionConstructor_FirmConstructionLabourDemand(current_xmachine_firm)==1)
13191  {
13192 
13193 
13194 
13195  i = firm_production_construction_plan();
13196 
13197 
13198 
13199  if(i == 1)
13200  {
13201  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionConstructor_state);
13202  }
13203  else
13204  {
13205  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionConstructor_state, firm_FirmConstructionLabourDemand_state);
13206  }
13207  }
13208 
13209  current_xmachine_firm = NULL;
13210 
13211  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13212  }
13213  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_construction_plan\n");
13214 
13215 
13216  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_construct_houses\n");
13217  current_xmachine_firm_holder = firm_FirmProductionConstructor_state->agents;
13218  while(current_xmachine_firm_holder)
13219  {
13220  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13221  current_xmachine_firm = current_xmachine_firm_holder->agent;
13222  current_xmachine_firm_next_state = firm_FirmLabourStart_state;
13223  /* For backwards compatibility set current_xmachine */
13224  current_xmachine->xmachine_firm = NULL;
13225  current_xmachine->xmachine_household = NULL;
13226  current_xmachine->xmachine_equityfund = NULL;
13227  current_xmachine->xmachine_bank = NULL;
13228  current_xmachine->xmachine_government = NULL;
13229  current_xmachine->xmachine_centralbank = NULL;
13230  current_xmachine->xmachine_jpoffice = NULL;
13231  current_xmachine->xmachine_mall = NULL;
13232  current_xmachine->xmachine_reagency = NULL;
13233  current_xmachine->xmachine_firm = current_xmachine_firm;
13234 
13235  if(FLAME_condition_firm_firm_production_construct_houses_FirmProductionConstructor_FirmLabourStart(current_xmachine_firm)==1)
13236  {
13237 
13238 
13239 
13240  i = firm_production_construct_houses();
13241 
13242 
13243 
13244  if(i == 1)
13245  {
13246  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionConstructor_state);
13247  }
13248  else
13249  {
13250  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionConstructor_state, firm_FirmLabourStart_state);
13251  }
13252  }
13253 
13254  current_xmachine_firm = NULL;
13255 
13256  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13257  }
13258  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_construct_houses\n");
13259 
13260 
13261  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_set_price\n");
13262  current_xmachine_firm_holder = firm_FirmProductionRegular_state->agents;
13263  while(current_xmachine_firm_holder)
13264  {
13265  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13266  current_xmachine_firm = current_xmachine_firm_holder->agent;
13267  current_xmachine_firm_next_state = firm_FirmProductionPlanning_state;
13268  /* For backwards compatibility set current_xmachine */
13269  current_xmachine->xmachine_firm = NULL;
13270  current_xmachine->xmachine_household = NULL;
13271  current_xmachine->xmachine_equityfund = NULL;
13272  current_xmachine->xmachine_bank = NULL;
13273  current_xmachine->xmachine_government = NULL;
13274  current_xmachine->xmachine_centralbank = NULL;
13275  current_xmachine->xmachine_jpoffice = NULL;
13276  current_xmachine->xmachine_mall = NULL;
13277  current_xmachine->xmachine_reagency = NULL;
13278  current_xmachine->xmachine_firm = current_xmachine_firm;
13279 
13280  if(FLAME_condition_firm_firm_production_set_price_FirmProductionRegular_FirmProductionPlanning(current_xmachine_firm)==1)
13281  {
13282 
13283 
13284 
13285  i = firm_production_set_price();
13286 
13287 
13288 
13289  if(i == 1)
13290  {
13291  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRegular_state);
13292  }
13293  else
13294  {
13295  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRegular_state, firm_FirmProductionPlanning_state);
13296  }
13297  }
13298 
13299  current_xmachine_firm = NULL;
13300 
13301  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13302  }
13303  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_set_price\n");
13304 
13305 
13306  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_produce_goods\n");
13307  current_xmachine_firm_holder = firm_FirmProductionRegular_state->agents;
13308  while(current_xmachine_firm_holder)
13309  {
13310  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13311  current_xmachine_firm = current_xmachine_firm_holder->agent;
13312  current_xmachine_firm_next_state = firm_FirmLabourStart_state;
13313  /* For backwards compatibility set current_xmachine */
13314  current_xmachine->xmachine_firm = NULL;
13315  current_xmachine->xmachine_household = NULL;
13316  current_xmachine->xmachine_equityfund = NULL;
13317  current_xmachine->xmachine_bank = NULL;
13318  current_xmachine->xmachine_government = NULL;
13319  current_xmachine->xmachine_centralbank = NULL;
13320  current_xmachine->xmachine_jpoffice = NULL;
13321  current_xmachine->xmachine_mall = NULL;
13322  current_xmachine->xmachine_reagency = NULL;
13323  current_xmachine->xmachine_firm = current_xmachine_firm;
13324 
13325  if(FLAME_condition_firm_firm_production_produce_goods_FirmProductionRegular_FirmLabourStart(current_xmachine_firm)==1)
13326  {
13327 
13328 
13329 
13330  i = firm_production_produce_goods();
13331 
13332 
13333 
13334  if(i == 1)
13335  {
13336  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRegular_state);
13337  }
13338  else
13339  {
13340  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionRegular_state, firm_FirmLabourStart_state);
13341  }
13342  }
13343 
13344  current_xmachine_firm = NULL;
13345 
13346  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13347  }
13348  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_produce_goods\n");
13349 
13350 
13351  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_credit_check_interest_rate\n");
13352  current_xmachine_bank_holder = bank_BankCreditCheckInterestRate_state->agents;
13353  while(current_xmachine_bank_holder)
13354  {
13355  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
13356  current_xmachine_bank = current_xmachine_bank_holder->agent;
13357  current_xmachine_bank_next_state = bank_BankHousingMarket_state;
13358  /* For backwards compatibility set current_xmachine */
13359  current_xmachine->xmachine_firm = NULL;
13360  current_xmachine->xmachine_household = NULL;
13361  current_xmachine->xmachine_equityfund = NULL;
13362  current_xmachine->xmachine_bank = NULL;
13363  current_xmachine->xmachine_government = NULL;
13364  current_xmachine->xmachine_centralbank = NULL;
13365  current_xmachine->xmachine_jpoffice = NULL;
13366  current_xmachine->xmachine_mall = NULL;
13367  current_xmachine->xmachine_reagency = NULL;
13368  current_xmachine->xmachine_bank = current_xmachine_bank;
13369 
13370 
13371 
13372 
13373 
13374 
13375  rc = MB_Iterator_Create(b_interest_rate, &i_interest_rate);
13376 
13377 
13378  #ifdef ERRCHECK
13379  if (rc != MB_SUCCESS)
13380  {
13381  fprintf(stderr, "ERROR: Could not create Iterator for 'interest_rate'\n");
13382  switch(rc) {
13383  case MB_ERR_INVALID:
13384  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
13385  break;
13386  case MB_ERR_LOCKED:
13387  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
13388  break;
13389  case MB_ERR_MEMALLOC:
13390  fprintf(stderr, "\t reason: out of memory\n");
13391  break;
13392  case MB_ERR_INTERNAL:
13393  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13394  break;
13395  default:
13396 
13397 
13398  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
13399 
13400  break;
13401  }
13402 
13403 
13404  exit(rc);
13405  }
13406  #endif
13407 
13408 
13409 
13410  i = bank_credit_check_interest_rate();
13411 
13412 
13413  rc = MB_Iterator_Delete(&i_interest_rate);
13414  #ifdef ERRCHECK
13415  if (rc != MB_SUCCESS)
13416  {
13417  fprintf(stderr, "ERROR: Could not delete 'interest_rate' iterator\n");
13418  switch(rc) {
13419  case MB_ERR_INVALID:
13420  fprintf(stderr, "\t reason: 'interest_rate' iterator is invalid\n");
13421  break;
13422  case MB_ERR_INTERNAL:
13423  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13424  break;
13425  default:
13426  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
13427  break;
13428  }
13429 
13430 
13431  exit(rc);
13432  }
13433  #endif
13434 
13435 
13436  if(i == 1)
13437  {
13438  free_bank_agent(current_xmachine_bank_holder, bank_BankCreditCheckInterestRate_state);
13439  }
13440  else
13441  {
13442  transition_bank_agent(current_xmachine_bank_holder, bank_BankCreditCheckInterestRate_state, bank_BankHousingMarket_state);
13443  }
13444 
13445 
13446  current_xmachine_bank = NULL;
13447 
13448  current_xmachine_bank_holder = temp_xmachine_bank_holder;
13449  }
13450  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_credit_check_interest_rate\n");
13451 
13452 
13453 /* End of layer number 23 */
13454 
13455 /* Clear message boards that have finished being used
13456  * and sync complete if doing late sync complete */
13457 
13458 if(FLAME_interest_rate_message_board_read == 0)
13459 {
13460  /*printf("%d> interest_rate message board sync complete late as no agents reading any messages of this type\n", node_number);*/
13461 
13462  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_interest_rate)\n");
13463  rc = MB_SyncComplete(b_interest_rate);
13464  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_interest_rate)\n");
13465  #ifdef ERRCHECK
13466  if (rc != MB_SUCCESS)
13467  {
13468  fprintf(stderr, "ERROR: Could not complete sync of 'interest_rate' board\n");
13469  switch(rc) {
13470  case MB_ERR_INVALID:
13471  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
13472  break;
13473  case MB_ERR_MEMALLOC:
13474  fprintf(stderr, "\t reason: out of memory\n");
13475  break;
13476  case MB_ERR_INTERNAL:
13477  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13478  break;
13479  default:
13480  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
13481  break;
13482  }
13483 
13484 
13485  exit(rc);
13486  }
13487  #endif
13488 }
13489 
13490  /* Delete any search trees */
13491 
13492  rc = MB_Clear(b_interest_rate);
13493  #ifdef ERRCHECK
13494  if (rc != MB_SUCCESS)
13495  {
13496  fprintf(stderr, "ERROR: Could not clear 'interest_rate' board\n");
13497  switch(rc) {
13498  case MB_ERR_INVALID:
13499  fprintf(stderr, "\t reason: 'interest_rate' board is invalid\n");
13500  break;
13501  case MB_ERR_LOCKED:
13502  fprintf(stderr, "\t reason: 'interest_rate' board is locked\n");
13503  break;
13504  case MB_ERR_INTERNAL:
13505  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13506  break;
13507  default:
13508  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
13509  break;
13510 
13511  }
13512 
13513 
13514  exit(rc);
13515  }
13516  #endif
13517 
13518  /* DEBUG: States with branching functions */
13519  current_xmachine_bank_holder = bank_BankHousingMarket_state->agents;
13520  while(current_xmachine_bank_holder)
13521  {
13522  FLAME_debug_count = 0;
13523  /* Function: bank_housing_compute_capital_status */
13524  if(FLAME_condition_bank_bank_housing_compute_capital_status_BankHousingMarket_BankHousingCrediting(current_xmachine_bank_holder->agent)==1)
13525  { FLAME_debug_count++; }
13526  /* Function: idle */
13527  if(FLAME_condition_bank_idle_BankHousingMarket_BankUpdateDeposits(current_xmachine_bank_holder->agent)==1)
13528  { FLAME_debug_count++; }
13529  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
13530  if(FLAME_debug_count != 1)
13531  {
13532  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'bank' leaving state 'BankHousingMarket'\n");
13533  if(FLAME_debug_count > 1)
13534  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
13535  if(FLAME_debug_count == 0)
13536  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
13537  }
13538 
13539  current_xmachine_bank_holder = current_xmachine_bank_holder->next;
13540  }
13541 
13542  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_housing_compute_capital_status\n");
13543  current_xmachine_bank_holder = bank_BankHousingMarket_state->agents;
13544  while(current_xmachine_bank_holder)
13545  {
13546  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
13547  current_xmachine_bank = current_xmachine_bank_holder->agent;
13548  current_xmachine_bank_next_state = bank_BankHousingCrediting_state;
13549  /* For backwards compatibility set current_xmachine */
13550  current_xmachine->xmachine_firm = NULL;
13551  current_xmachine->xmachine_household = NULL;
13552  current_xmachine->xmachine_equityfund = NULL;
13553  current_xmachine->xmachine_bank = NULL;
13554  current_xmachine->xmachine_government = NULL;
13555  current_xmachine->xmachine_centralbank = NULL;
13556  current_xmachine->xmachine_jpoffice = NULL;
13557  current_xmachine->xmachine_mall = NULL;
13558  current_xmachine->xmachine_reagency = NULL;
13559  current_xmachine->xmachine_bank = current_xmachine_bank;
13560 
13561  if(FLAME_condition_bank_bank_housing_compute_capital_status_BankHousingMarket_BankHousingCrediting(current_xmachine_bank)==1)
13562  {
13563 
13564 
13565 
13566  i = bank_housing_compute_capital_status();
13567 
13568 
13569 
13570  if(i == 1)
13571  {
13572  free_bank_agent(current_xmachine_bank_holder, bank_BankHousingMarket_state);
13573  }
13574  else
13575  {
13576  transition_bank_agent(current_xmachine_bank_holder, bank_BankHousingMarket_state, bank_BankHousingCrediting_state);
13577  }
13578  }
13579 
13580  current_xmachine_bank = NULL;
13581 
13582  current_xmachine_bank_holder = temp_xmachine_bank_holder;
13583  }
13584  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_housing_compute_capital_status\n");
13585 
13586  if(FLAME_mortgaging_capacity_message_board_write == 1)
13587  {
13588 
13589  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgaging_capacity)\n");
13590  rc = MB_SyncStart(b_mortgaging_capacity);
13591  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgaging_capacity)\n");
13592  #ifdef ERRCHECK
13593  if (rc != MB_SUCCESS)
13594  {
13595  fprintf(stderr, "ERROR: Could not start sync of 'mortgaging_capacity' board\n");
13596  switch(rc) {
13597  case MB_ERR_INVALID:
13598  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is invalid\n");
13599  break;
13600  case MB_ERR_LOCKED:
13601  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is locked\n");
13602  break;
13603  case MB_ERR_MEMALLOC:
13604  fprintf(stderr, "\t reason: out of memory\n");
13605  break;
13606  case MB_ERR_INTERNAL:
13607  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
13608  break;
13609  default:
13610  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
13611  break;
13612  }
13613 
13614 
13615  exit(rc);
13616  }
13617  #endif
13618  }
13619 
13620 
13621 
13622  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
13623  current_xmachine_bank_holder = bank_BankHousingMarket_state->agents;
13624  while(current_xmachine_bank_holder)
13625  {
13626  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
13627  current_xmachine_bank = current_xmachine_bank_holder->agent;
13628  current_xmachine_bank_next_state = bank_BankUpdateDeposits_state;
13629  /* For backwards compatibility set current_xmachine */
13630  current_xmachine->xmachine_firm = NULL;
13631  current_xmachine->xmachine_household = NULL;
13632  current_xmachine->xmachine_equityfund = NULL;
13633  current_xmachine->xmachine_bank = NULL;
13634  current_xmachine->xmachine_government = NULL;
13635  current_xmachine->xmachine_centralbank = NULL;
13636  current_xmachine->xmachine_jpoffice = NULL;
13637  current_xmachine->xmachine_mall = NULL;
13638  current_xmachine->xmachine_reagency = NULL;
13639  current_xmachine->xmachine_bank = current_xmachine_bank;
13640 
13641  if(FLAME_condition_bank_idle_BankHousingMarket_BankUpdateDeposits(current_xmachine_bank)==1)
13642  {
13643 
13644 
13645 
13646  i = idle();
13647 
13648 
13649 
13650  if(i == 1)
13651  {
13652  free_bank_agent(current_xmachine_bank_holder, bank_BankHousingMarket_state);
13653  }
13654  else
13655  {
13656  transition_bank_agent(current_xmachine_bank_holder, bank_BankHousingMarket_state, bank_BankUpdateDeposits_state);
13657  }
13658  }
13659 
13660  current_xmachine_bank = NULL;
13661 
13662  current_xmachine_bank_holder = temp_xmachine_bank_holder;
13663  }
13664  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
13665 
13666 
13667  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_construction_labour_demand\n");
13668  current_xmachine_firm_holder = firm_FirmConstructionLabourDemand_state->agents;
13669  while(current_xmachine_firm_holder)
13670  {
13671  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13672  current_xmachine_firm = current_xmachine_firm_holder->agent;
13673  current_xmachine_firm_next_state = firm_FirmLabourStart_state;
13674  /* For backwards compatibility set current_xmachine */
13675  current_xmachine->xmachine_firm = NULL;
13676  current_xmachine->xmachine_household = NULL;
13677  current_xmachine->xmachine_equityfund = NULL;
13678  current_xmachine->xmachine_bank = NULL;
13679  current_xmachine->xmachine_government = NULL;
13680  current_xmachine->xmachine_centralbank = NULL;
13681  current_xmachine->xmachine_jpoffice = NULL;
13682  current_xmachine->xmachine_mall = NULL;
13683  current_xmachine->xmachine_reagency = NULL;
13684  current_xmachine->xmachine_firm = current_xmachine_firm;
13685 
13686 
13687 
13688 
13689 
13690  i = firm_production_construction_labour_demand();
13691 
13692 
13693 
13694  if(i == 1)
13695  {
13696  free_firm_agent(current_xmachine_firm_holder, firm_FirmConstructionLabourDemand_state);
13697  }
13698  else
13699  {
13700  transition_firm_agent(current_xmachine_firm_holder, firm_FirmConstructionLabourDemand_state, firm_FirmLabourStart_state);
13701  }
13702 
13703 
13704  current_xmachine_firm = NULL;
13705 
13706  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13707  }
13708  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_construction_labour_demand\n");
13709 
13710 
13711  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_plan\n");
13712  current_xmachine_firm_holder = firm_FirmProductionPlanning_state->agents;
13713  while(current_xmachine_firm_holder)
13714  {
13715  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13716  current_xmachine_firm = current_xmachine_firm_holder->agent;
13717  current_xmachine_firm_next_state = firm_FirmProductionLabourDemand_state;
13718  /* For backwards compatibility set current_xmachine */
13719  current_xmachine->xmachine_firm = NULL;
13720  current_xmachine->xmachine_household = NULL;
13721  current_xmachine->xmachine_equityfund = NULL;
13722  current_xmachine->xmachine_bank = NULL;
13723  current_xmachine->xmachine_government = NULL;
13724  current_xmachine->xmachine_centralbank = NULL;
13725  current_xmachine->xmachine_jpoffice = NULL;
13726  current_xmachine->xmachine_mall = NULL;
13727  current_xmachine->xmachine_reagency = NULL;
13728  current_xmachine->xmachine_firm = current_xmachine_firm;
13729 
13730 
13731 
13732 
13733 
13734  i = firm_production_plan();
13735 
13736 
13737 
13738  if(i == 1)
13739  {
13740  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionPlanning_state);
13741  }
13742  else
13743  {
13744  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionPlanning_state, firm_FirmProductionLabourDemand_state);
13745  }
13746 
13747 
13748  current_xmachine_firm = NULL;
13749 
13750  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13751  }
13752  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_plan\n");
13753 
13754 
13755 /* End of layer number 24 */
13756 
13757 /* Clear message boards that have finished being used
13758  * and sync complete if doing late sync complete */
13759 
13760 
13761  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_production_compute_labour_demand\n");
13762  current_xmachine_firm_holder = firm_FirmProductionLabourDemand_state->agents;
13763  while(current_xmachine_firm_holder)
13764  {
13765  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13766  current_xmachine_firm = current_xmachine_firm_holder->agent;
13767  current_xmachine_firm_next_state = firm_FirmLabourStart_state;
13768  /* For backwards compatibility set current_xmachine */
13769  current_xmachine->xmachine_firm = NULL;
13770  current_xmachine->xmachine_household = NULL;
13771  current_xmachine->xmachine_equityfund = NULL;
13772  current_xmachine->xmachine_bank = NULL;
13773  current_xmachine->xmachine_government = NULL;
13774  current_xmachine->xmachine_centralbank = NULL;
13775  current_xmachine->xmachine_jpoffice = NULL;
13776  current_xmachine->xmachine_mall = NULL;
13777  current_xmachine->xmachine_reagency = NULL;
13778  current_xmachine->xmachine_firm = current_xmachine_firm;
13779 
13780 
13781 
13782 
13783 
13784  i = firm_production_compute_labour_demand();
13785 
13786 
13787 
13788  if(i == 1)
13789  {
13790  free_firm_agent(current_xmachine_firm_holder, firm_FirmProductionLabourDemand_state);
13791  }
13792  else
13793  {
13794  transition_firm_agent(current_xmachine_firm_holder, firm_FirmProductionLabourDemand_state, firm_FirmLabourStart_state);
13795  }
13796 
13797 
13798  current_xmachine_firm = NULL;
13799 
13800  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13801  }
13802  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_production_compute_labour_demand\n");
13803 
13804 
13805 /* End of layer number 25 */
13806 
13807 /* Clear message boards that have finished being used
13808  * and sync complete if doing late sync complete */
13809 
13810  /* DEBUG: States with branching functions */
13811  current_xmachine_firm_holder = firm_FirmLabourStart_state->agents;
13812  while(current_xmachine_firm_holder)
13813  {
13814  FLAME_debug_count = 0;
13815  /* Function: firm_labour_workforce_needed */
13816  if(FLAME_condition_firm_firm_labour_workforce_needed_FirmLabourStart_FirmLabourStage1(current_xmachine_firm_holder->agent)==1)
13817  { FLAME_debug_count++; }
13818  /* Function: idle */
13819  if(FLAME_condition_firm_idle_FirmLabourStart_FirmLabourPayWages(current_xmachine_firm_holder->agent)==1)
13820  { FLAME_debug_count++; }
13821  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
13822  if(FLAME_debug_count != 1)
13823  {
13824  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmLabourStart'\n");
13825  if(FLAME_debug_count > 1)
13826  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
13827  if(FLAME_debug_count == 0)
13828  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
13829  }
13830 
13831  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
13832  }
13833 
13834  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_workforce_needed\n");
13835  current_xmachine_firm_holder = firm_FirmLabourStart_state->agents;
13836  while(current_xmachine_firm_holder)
13837  {
13838  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13839  current_xmachine_firm = current_xmachine_firm_holder->agent;
13840  current_xmachine_firm_next_state = firm_FirmLabourStage1_state;
13841  /* For backwards compatibility set current_xmachine */
13842  current_xmachine->xmachine_firm = NULL;
13843  current_xmachine->xmachine_household = NULL;
13844  current_xmachine->xmachine_equityfund = NULL;
13845  current_xmachine->xmachine_bank = NULL;
13846  current_xmachine->xmachine_government = NULL;
13847  current_xmachine->xmachine_centralbank = NULL;
13848  current_xmachine->xmachine_jpoffice = NULL;
13849  current_xmachine->xmachine_mall = NULL;
13850  current_xmachine->xmachine_reagency = NULL;
13851  current_xmachine->xmachine_firm = current_xmachine_firm;
13852 
13853  if(FLAME_condition_firm_firm_labour_workforce_needed_FirmLabourStart_FirmLabourStage1(current_xmachine_firm)==1)
13854  {
13855 
13856 
13857 
13858  i = firm_labour_workforce_needed();
13859 
13860 
13861 
13862  if(i == 1)
13863  {
13864  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStart_state);
13865  }
13866  else
13867  {
13868  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStart_state, firm_FirmLabourStage1_state);
13869  }
13870  }
13871 
13872  current_xmachine_firm = NULL;
13873 
13874  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13875  }
13876  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_workforce_needed\n");
13877 
13878 
13879  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
13880  current_xmachine_firm_holder = firm_FirmLabourStart_state->agents;
13881  while(current_xmachine_firm_holder)
13882  {
13883  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13884  current_xmachine_firm = current_xmachine_firm_holder->agent;
13885  current_xmachine_firm_next_state = firm_FirmLabourPayWages_state;
13886  /* For backwards compatibility set current_xmachine */
13887  current_xmachine->xmachine_firm = NULL;
13888  current_xmachine->xmachine_household = NULL;
13889  current_xmachine->xmachine_equityfund = NULL;
13890  current_xmachine->xmachine_bank = NULL;
13891  current_xmachine->xmachine_government = NULL;
13892  current_xmachine->xmachine_centralbank = NULL;
13893  current_xmachine->xmachine_jpoffice = NULL;
13894  current_xmachine->xmachine_mall = NULL;
13895  current_xmachine->xmachine_reagency = NULL;
13896  current_xmachine->xmachine_firm = current_xmachine_firm;
13897 
13898  if(FLAME_condition_firm_idle_FirmLabourStart_FirmLabourPayWages(current_xmachine_firm)==1)
13899  {
13900 
13901 
13902 
13903  i = idle();
13904 
13905 
13906 
13907  if(i == 1)
13908  {
13909  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStart_state);
13910  }
13911  else
13912  {
13913  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStart_state, firm_FirmLabourPayWages_state);
13914  }
13915  }
13916 
13917  current_xmachine_firm = NULL;
13918 
13919  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13920  }
13921  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
13922 
13923 
13924 /* End of layer number 26 */
13925 
13926 /* Clear message boards that have finished being used
13927  * and sync complete if doing late sync complete */
13928 
13929  /* DEBUG: States with branching functions */
13930  current_xmachine_firm_holder = firm_FirmLabourStage1_state->agents;
13931  while(current_xmachine_firm_holder)
13932  {
13933  FLAME_debug_count = 0;
13934  /* Function: firm_labour_job_announcement_stage1 */
13935  if(FLAME_condition_firm_firm_labour_job_announcement_stage1_FirmLabourStage1_FirmLabourStage1Application(current_xmachine_firm_holder->agent)==1)
13936  { FLAME_debug_count++; }
13937  /* Function: firm_labour_fire */
13938  if(FLAME_condition_firm_firm_labour_fire_FirmLabourStage1_FirmLabourStage1End(current_xmachine_firm_holder->agent)==1)
13939  { FLAME_debug_count++; }
13940  /* Function: idle */
13941  if(FLAME_condition_firm_idle_FirmLabourStage1_FirmLabourStage1End(current_xmachine_firm_holder->agent)==1)
13942  { FLAME_debug_count++; }
13943  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
13944  if(FLAME_debug_count != 1)
13945  {
13946  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmLabourStage1'\n");
13947  if(FLAME_debug_count > 1)
13948  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
13949  if(FLAME_debug_count == 0)
13950  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
13951  }
13952 
13953  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
13954  }
13955 
13956  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_fire\n");
13957  current_xmachine_firm_holder = firm_FirmLabourStage1_state->agents;
13958  while(current_xmachine_firm_holder)
13959  {
13960  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
13961  current_xmachine_firm = current_xmachine_firm_holder->agent;
13962  current_xmachine_firm_next_state = firm_FirmLabourStage1End_state;
13963  /* For backwards compatibility set current_xmachine */
13964  current_xmachine->xmachine_firm = NULL;
13965  current_xmachine->xmachine_household = NULL;
13966  current_xmachine->xmachine_equityfund = NULL;
13967  current_xmachine->xmachine_bank = NULL;
13968  current_xmachine->xmachine_government = NULL;
13969  current_xmachine->xmachine_centralbank = NULL;
13970  current_xmachine->xmachine_jpoffice = NULL;
13971  current_xmachine->xmachine_mall = NULL;
13972  current_xmachine->xmachine_reagency = NULL;
13973  current_xmachine->xmachine_firm = current_xmachine_firm;
13974 
13975  if(FLAME_condition_firm_firm_labour_fire_FirmLabourStage1_FirmLabourStage1End(current_xmachine_firm)==1)
13976  {
13977 
13978 
13979 
13980  i = firm_labour_fire();
13981 
13982 
13983 
13984  if(i == 1)
13985  {
13986  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1_state);
13987  }
13988  else
13989  {
13990  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1_state, firm_FirmLabourStage1End_state);
13991  }
13992  }
13993 
13994  current_xmachine_firm = NULL;
13995 
13996  current_xmachine_firm_holder = temp_xmachine_firm_holder;
13997  }
13998  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_fire\n");
13999 
14000  if(FLAME_fired_message_board_write == 1)
14001  {
14002 
14003  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_fired)\n");
14004  rc = MB_SyncStart(b_fired);
14005  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_fired)\n");
14006  #ifdef ERRCHECK
14007  if (rc != MB_SUCCESS)
14008  {
14009  fprintf(stderr, "ERROR: Could not start sync of 'fired' board\n");
14010  switch(rc) {
14011  case MB_ERR_INVALID:
14012  fprintf(stderr, "\t reason: 'fired' board is invalid\n");
14013  break;
14014  case MB_ERR_LOCKED:
14015  fprintf(stderr, "\t reason: 'fired' board is locked\n");
14016  break;
14017  case MB_ERR_MEMALLOC:
14018  fprintf(stderr, "\t reason: out of memory\n");
14019  break;
14020  case MB_ERR_INTERNAL:
14021  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14022  break;
14023  default:
14024  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
14025  break;
14026  }
14027 
14028 
14029  exit(rc);
14030  }
14031  #endif
14032  }
14033 
14034 
14035 
14036  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_job_announcement_stage1\n");
14037  current_xmachine_firm_holder = firm_FirmLabourStage1_state->agents;
14038  while(current_xmachine_firm_holder)
14039  {
14040  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
14041  current_xmachine_firm = current_xmachine_firm_holder->agent;
14042  current_xmachine_firm_next_state = firm_FirmLabourStage1Application_state;
14043  /* For backwards compatibility set current_xmachine */
14044  current_xmachine->xmachine_firm = NULL;
14045  current_xmachine->xmachine_household = NULL;
14046  current_xmachine->xmachine_equityfund = NULL;
14047  current_xmachine->xmachine_bank = NULL;
14048  current_xmachine->xmachine_government = NULL;
14049  current_xmachine->xmachine_centralbank = NULL;
14050  current_xmachine->xmachine_jpoffice = NULL;
14051  current_xmachine->xmachine_mall = NULL;
14052  current_xmachine->xmachine_reagency = NULL;
14053  current_xmachine->xmachine_firm = current_xmachine_firm;
14054 
14055  if(FLAME_condition_firm_firm_labour_job_announcement_stage1_FirmLabourStage1_FirmLabourStage1Application(current_xmachine_firm)==1)
14056  {
14057 
14058 
14059 
14060  i = firm_labour_job_announcement_stage1();
14061 
14062 
14063 
14064  if(i == 1)
14065  {
14066  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1_state);
14067  }
14068  else
14069  {
14070  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1_state, firm_FirmLabourStage1Application_state);
14071  }
14072  }
14073 
14074  current_xmachine_firm = NULL;
14075 
14076  current_xmachine_firm_holder = temp_xmachine_firm_holder;
14077  }
14078  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_job_announcement_stage1\n");
14079 
14080  if(FLAME_vacancy_stage1_message_board_write == 1)
14081  {
14082 
14083  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_vacancy_stage1)\n");
14084  rc = MB_SyncStart(b_vacancy_stage1);
14085  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_vacancy_stage1)\n");
14086  #ifdef ERRCHECK
14087  if (rc != MB_SUCCESS)
14088  {
14089  fprintf(stderr, "ERROR: Could not start sync of 'vacancy_stage1' board\n");
14090  switch(rc) {
14091  case MB_ERR_INVALID:
14092  fprintf(stderr, "\t reason: 'vacancy_stage1' board is invalid\n");
14093  break;
14094  case MB_ERR_LOCKED:
14095  fprintf(stderr, "\t reason: 'vacancy_stage1' board is locked\n");
14096  break;
14097  case MB_ERR_MEMALLOC:
14098  fprintf(stderr, "\t reason: out of memory\n");
14099  break;
14100  case MB_ERR_INTERNAL:
14101  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14102  break;
14103  default:
14104  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
14105  break;
14106  }
14107 
14108 
14109  exit(rc);
14110  }
14111  #endif
14112  }
14113 
14114 
14115 
14116  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
14117  current_xmachine_firm_holder = firm_FirmLabourStage1_state->agents;
14118  while(current_xmachine_firm_holder)
14119  {
14120  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
14121  current_xmachine_firm = current_xmachine_firm_holder->agent;
14122  current_xmachine_firm_next_state = firm_FirmLabourStage1End_state;
14123  /* For backwards compatibility set current_xmachine */
14124  current_xmachine->xmachine_firm = NULL;
14125  current_xmachine->xmachine_household = NULL;
14126  current_xmachine->xmachine_equityfund = NULL;
14127  current_xmachine->xmachine_bank = NULL;
14128  current_xmachine->xmachine_government = NULL;
14129  current_xmachine->xmachine_centralbank = NULL;
14130  current_xmachine->xmachine_jpoffice = NULL;
14131  current_xmachine->xmachine_mall = NULL;
14132  current_xmachine->xmachine_reagency = NULL;
14133  current_xmachine->xmachine_firm = current_xmachine_firm;
14134 
14135  if(FLAME_condition_firm_idle_FirmLabourStage1_FirmLabourStage1End(current_xmachine_firm)==1)
14136  {
14137 
14138 
14139 
14140  i = idle();
14141 
14142 
14143 
14144  if(i == 1)
14145  {
14146  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1_state);
14147  }
14148  else
14149  {
14150  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1_state, firm_FirmLabourStage1End_state);
14151  }
14152  }
14153 
14154  current_xmachine_firm = NULL;
14155 
14156  current_xmachine_firm_holder = temp_xmachine_firm_holder;
14157  }
14158  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
14159 
14160 
14161 /* End of layer number 27 */
14162 
14163 /* Clear message boards that have finished being used
14164  * and sync complete if doing late sync complete */
14165 
14166 
14167  /* If mb is not read then leave sync complete until last possible moment */
14168  if(FLAME_fired_message_board_read == 1)
14169  {
14170  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_fired)\n");
14171  rc = MB_SyncComplete(b_fired);
14172  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_fired)\n");
14173  #ifdef ERRCHECK
14174  if (rc != MB_SUCCESS)
14175  {
14176  fprintf(stderr, "ERROR: Could not complete sync of 'fired' board\n");
14177  switch(rc) {
14178  case MB_ERR_INVALID:
14179  fprintf(stderr, "\t reason: 'fired' board is invalid\n");
14180  break;
14181  case MB_ERR_MEMALLOC:
14182  fprintf(stderr, "\t reason: out of memory\n");
14183  break;
14184  case MB_ERR_INTERNAL:
14185  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14186  break;
14187  default:
14188  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
14189  break;
14190  }
14191 
14192 
14193  exit(rc);
14194  }
14195  #endif
14196 
14197 
14198 
14199  }
14200 
14201  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_labour_check_fired\n");
14202  current_xmachine_household_holder = household_HHLabourStart_state->agents;
14203  while(current_xmachine_household_holder)
14204  {
14205  temp_xmachine_household_holder = current_xmachine_household_holder->next;
14206  current_xmachine_household = current_xmachine_household_holder->agent;
14207  current_xmachine_household_next_state = household_HHLabourStage1_state;
14208  /* For backwards compatibility set current_xmachine */
14209  current_xmachine->xmachine_firm = NULL;
14210  current_xmachine->xmachine_household = NULL;
14211  current_xmachine->xmachine_equityfund = NULL;
14212  current_xmachine->xmachine_bank = NULL;
14213  current_xmachine->xmachine_government = NULL;
14214  current_xmachine->xmachine_centralbank = NULL;
14215  current_xmachine->xmachine_jpoffice = NULL;
14216  current_xmachine->xmachine_mall = NULL;
14217  current_xmachine->xmachine_reagency = NULL;
14218  current_xmachine->xmachine_household = current_xmachine_household;
14219 
14220  if(FLAME_condition_household_household_labour_check_fired_HHLabourStart_HHLabourStage1(current_xmachine_household)==1)
14221  {
14222 
14223 
14224 
14225 
14226 
14227 
14228  rc = MB_Iterator_CreateFiltered(b_fired, &i_fired, &FLAME_filter_household_household_labour_check_fired_HHLabourStart_HHLabourStage1_fired, current_xmachine_household);
14229 
14230 
14231 
14232  #ifdef ERRCHECK
14233  if (rc != MB_SUCCESS)
14234  {
14235  fprintf(stderr, "ERROR: Could not create Iterator for 'fired'\n");
14236  switch(rc) {
14237  case MB_ERR_INVALID:
14238  fprintf(stderr, "\t reason: 'fired' board is invalid\n");
14239  break;
14240  case MB_ERR_LOCKED:
14241  fprintf(stderr, "\t reason: 'fired' board is locked\n");
14242  break;
14243  case MB_ERR_MEMALLOC:
14244  fprintf(stderr, "\t reason: out of memory\n");
14245  break;
14246  case MB_ERR_INTERNAL:
14247  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14248  break;
14249  default:
14250 
14251  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
14252 
14253 
14254  break;
14255  }
14256 
14257 
14258  exit(rc);
14259  }
14260  #endif
14261 
14262 
14263 
14264  i = household_labour_check_fired();
14265 
14266 
14267  rc = MB_Iterator_Delete(&i_fired);
14268  #ifdef ERRCHECK
14269  if (rc != MB_SUCCESS)
14270  {
14271  fprintf(stderr, "ERROR: Could not delete 'fired' iterator\n");
14272  switch(rc) {
14273  case MB_ERR_INVALID:
14274  fprintf(stderr, "\t reason: 'fired' iterator is invalid\n");
14275  break;
14276  case MB_ERR_INTERNAL:
14277  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14278  break;
14279  default:
14280  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
14281  break;
14282  }
14283 
14284 
14285  exit(rc);
14286  }
14287  #endif
14288 
14289 
14290  if(i == 1)
14291  {
14292  free_household_agent(current_xmachine_household_holder, household_HHLabourStart_state);
14293  }
14294  else
14295  {
14296  transition_household_agent(current_xmachine_household_holder, household_HHLabourStart_state, household_HHLabourStage1_state);
14297  }
14298  }
14299 
14300  current_xmachine_household = NULL;
14301 
14302  current_xmachine_household_holder = temp_xmachine_household_holder;
14303  }
14304  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_labour_check_fired\n");
14305 
14306 
14307 /* End of layer number 28 */
14308 
14309 /* Clear message boards that have finished being used
14310  * and sync complete if doing late sync complete */
14311 
14312 if(FLAME_fired_message_board_read == 0)
14313 {
14314  /*printf("%d> fired message board sync complete late as no agents reading any messages of this type\n", node_number);*/
14315 
14316  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_fired)\n");
14317  rc = MB_SyncComplete(b_fired);
14318  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_fired)\n");
14319  #ifdef ERRCHECK
14320  if (rc != MB_SUCCESS)
14321  {
14322  fprintf(stderr, "ERROR: Could not complete sync of 'fired' board\n");
14323  switch(rc) {
14324  case MB_ERR_INVALID:
14325  fprintf(stderr, "\t reason: 'fired' board is invalid\n");
14326  break;
14327  case MB_ERR_MEMALLOC:
14328  fprintf(stderr, "\t reason: out of memory\n");
14329  break;
14330  case MB_ERR_INTERNAL:
14331  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14332  break;
14333  default:
14334  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
14335  break;
14336  }
14337 
14338 
14339  exit(rc);
14340  }
14341  #endif
14342 }
14343 
14344  /* Delete any search trees */
14345 
14346  rc = MB_Clear(b_fired);
14347  #ifdef ERRCHECK
14348  if (rc != MB_SUCCESS)
14349  {
14350  fprintf(stderr, "ERROR: Could not clear 'fired' board\n");
14351  switch(rc) {
14352  case MB_ERR_INVALID:
14353  fprintf(stderr, "\t reason: 'fired' board is invalid\n");
14354  break;
14355  case MB_ERR_LOCKED:
14356  fprintf(stderr, "\t reason: 'fired' board is locked\n");
14357  break;
14358  case MB_ERR_INTERNAL:
14359  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14360  break;
14361  default:
14362  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
14363  break;
14364 
14365  }
14366 
14367 
14368  exit(rc);
14369  }
14370  #endif
14371 
14372  /* DEBUG: States with branching functions */
14373  current_xmachine_household_holder = household_HHLabourStage1_state->agents;
14374  while(current_xmachine_household_holder)
14375  {
14376  FLAME_debug_count = 0;
14377  /* Function: idle */
14378  if(FLAME_condition_household_idle_HHLabourStage1_HHLabourStage1Applications(current_xmachine_household_holder->agent)==1)
14379  { FLAME_debug_count++; }
14380  /* Function: household_labour_reemployment_application */
14381  if(FLAME_condition_household_household_labour_reemployment_application_HHLabourStage1_HHLabourStage2(current_xmachine_household_holder->agent)==1)
14382  { FLAME_debug_count++; }
14383  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
14384  if(FLAME_debug_count != 1)
14385  {
14386  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHLabourStage1'\n");
14387  if(FLAME_debug_count > 1)
14388  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
14389  if(FLAME_debug_count == 0)
14390  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
14391  }
14392 
14393  current_xmachine_household_holder = current_xmachine_household_holder->next;
14394  }
14395 
14396  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_labour_reemployment_application\n");
14397  current_xmachine_household_holder = household_HHLabourStage1_state->agents;
14398  while(current_xmachine_household_holder)
14399  {
14400  temp_xmachine_household_holder = current_xmachine_household_holder->next;
14401  current_xmachine_household = current_xmachine_household_holder->agent;
14402  current_xmachine_household_next_state = household_HHLabourStage2_state;
14403  /* For backwards compatibility set current_xmachine */
14404  current_xmachine->xmachine_firm = NULL;
14405  current_xmachine->xmachine_household = NULL;
14406  current_xmachine->xmachine_equityfund = NULL;
14407  current_xmachine->xmachine_bank = NULL;
14408  current_xmachine->xmachine_government = NULL;
14409  current_xmachine->xmachine_centralbank = NULL;
14410  current_xmachine->xmachine_jpoffice = NULL;
14411  current_xmachine->xmachine_mall = NULL;
14412  current_xmachine->xmachine_reagency = NULL;
14413  current_xmachine->xmachine_household = current_xmachine_household;
14414 
14415  if(FLAME_condition_household_household_labour_reemployment_application_HHLabourStage1_HHLabourStage2(current_xmachine_household)==1)
14416  {
14417 
14418 
14419 
14420  i = household_labour_reemployment_application();
14421 
14422 
14423 
14424  if(i == 1)
14425  {
14426  free_household_agent(current_xmachine_household_holder, household_HHLabourStage1_state);
14427  }
14428  else
14429  {
14430  transition_household_agent(current_xmachine_household_holder, household_HHLabourStage1_state, household_HHLabourStage2_state);
14431  }
14432  }
14433 
14434  current_xmachine_household = NULL;
14435 
14436  current_xmachine_household_holder = temp_xmachine_household_holder;
14437  }
14438  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_labour_reemployment_application\n");
14439 
14440  if(FLAME_job_application_stage1_message_board_write == 1)
14441  {
14442 
14443  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_application_stage1)\n");
14444  rc = MB_SyncStart(b_job_application_stage1);
14445  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_application_stage1)\n");
14446  #ifdef ERRCHECK
14447  if (rc != MB_SUCCESS)
14448  {
14449  fprintf(stderr, "ERROR: Could not start sync of 'job_application_stage1' board\n");
14450  switch(rc) {
14451  case MB_ERR_INVALID:
14452  fprintf(stderr, "\t reason: 'job_application_stage1' board is invalid\n");
14453  break;
14454  case MB_ERR_LOCKED:
14455  fprintf(stderr, "\t reason: 'job_application_stage1' board is locked\n");
14456  break;
14457  case MB_ERR_MEMALLOC:
14458  fprintf(stderr, "\t reason: out of memory\n");
14459  break;
14460  case MB_ERR_INTERNAL:
14461  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14462  break;
14463  default:
14464  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
14465  break;
14466  }
14467 
14468 
14469  exit(rc);
14470  }
14471  #endif
14472  }
14473 
14474 
14475 
14476  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
14477  current_xmachine_household_holder = household_HHLabourStage1_state->agents;
14478  while(current_xmachine_household_holder)
14479  {
14480  temp_xmachine_household_holder = current_xmachine_household_holder->next;
14481  current_xmachine_household = current_xmachine_household_holder->agent;
14482  current_xmachine_household_next_state = household_HHLabourStage1Applications_state;
14483  /* For backwards compatibility set current_xmachine */
14484  current_xmachine->xmachine_firm = NULL;
14485  current_xmachine->xmachine_household = NULL;
14486  current_xmachine->xmachine_equityfund = NULL;
14487  current_xmachine->xmachine_bank = NULL;
14488  current_xmachine->xmachine_government = NULL;
14489  current_xmachine->xmachine_centralbank = NULL;
14490  current_xmachine->xmachine_jpoffice = NULL;
14491  current_xmachine->xmachine_mall = NULL;
14492  current_xmachine->xmachine_reagency = NULL;
14493  current_xmachine->xmachine_household = current_xmachine_household;
14494 
14495  if(FLAME_condition_household_idle_HHLabourStage1_HHLabourStage1Applications(current_xmachine_household)==1)
14496  {
14497 
14498 
14499 
14500  i = idle();
14501 
14502 
14503 
14504  if(i == 1)
14505  {
14506  free_household_agent(current_xmachine_household_holder, household_HHLabourStage1_state);
14507  }
14508  else
14509  {
14510  transition_household_agent(current_xmachine_household_holder, household_HHLabourStage1_state, household_HHLabourStage1Applications_state);
14511  }
14512  }
14513 
14514  current_xmachine_household = NULL;
14515 
14516  current_xmachine_household_holder = temp_xmachine_household_holder;
14517  }
14518  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
14519 
14520 
14521 /* End of layer number 29 */
14522 
14523 /* Clear message boards that have finished being used
14524  * and sync complete if doing late sync complete */
14525 
14526 
14527  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_labour_employment_application\n");
14528  current_xmachine_household_holder = household_HHLabourStage1Applications_state->agents;
14529  while(current_xmachine_household_holder)
14530  {
14531  temp_xmachine_household_holder = current_xmachine_household_holder->next;
14532  current_xmachine_household = current_xmachine_household_holder->agent;
14533  current_xmachine_household_next_state = household_HHLabourStage1Placement_state;
14534  /* For backwards compatibility set current_xmachine */
14535  current_xmachine->xmachine_firm = NULL;
14536  current_xmachine->xmachine_household = NULL;
14537  current_xmachine->xmachine_equityfund = NULL;
14538  current_xmachine->xmachine_bank = NULL;
14539  current_xmachine->xmachine_government = NULL;
14540  current_xmachine->xmachine_centralbank = NULL;
14541  current_xmachine->xmachine_jpoffice = NULL;
14542  current_xmachine->xmachine_mall = NULL;
14543  current_xmachine->xmachine_reagency = NULL;
14544  current_xmachine->xmachine_household = current_xmachine_household;
14545 
14546 
14547 
14548 
14549 
14550  i = household_labour_employment_application();
14551 
14552 
14553 
14554  if(i == 1)
14555  {
14556  free_household_agent(current_xmachine_household_holder, household_HHLabourStage1Applications_state);
14557  }
14558  else
14559  {
14560  transition_household_agent(current_xmachine_household_holder, household_HHLabourStage1Applications_state, household_HHLabourStage1Placement_state);
14561  }
14562 
14563 
14564  current_xmachine_household = NULL;
14565 
14566  current_xmachine_household_holder = temp_xmachine_household_holder;
14567  }
14568  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_labour_employment_application\n");
14569 
14570  if(FLAME_job_application_stage2_message_board_write == 1)
14571  {
14572 
14573  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_application_stage2)\n");
14574  rc = MB_SyncStart(b_job_application_stage2);
14575  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_application_stage2)\n");
14576  #ifdef ERRCHECK
14577  if (rc != MB_SUCCESS)
14578  {
14579  fprintf(stderr, "ERROR: Could not start sync of 'job_application_stage2' board\n");
14580  switch(rc) {
14581  case MB_ERR_INVALID:
14582  fprintf(stderr, "\t reason: 'job_application_stage2' board is invalid\n");
14583  break;
14584  case MB_ERR_LOCKED:
14585  fprintf(stderr, "\t reason: 'job_application_stage2' board is locked\n");
14586  break;
14587  case MB_ERR_MEMALLOC:
14588  fprintf(stderr, "\t reason: out of memory\n");
14589  break;
14590  case MB_ERR_INTERNAL:
14591  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14592  break;
14593  default:
14594  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
14595  break;
14596  }
14597 
14598 
14599  exit(rc);
14600  }
14601  #endif
14602  }
14603 
14604 
14605 
14606  /* If mb is not read then leave sync complete until last possible moment */
14607  if(FLAME_job_application_stage1_message_board_read == 1)
14608  {
14609  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_application_stage1)\n");
14610  rc = MB_SyncComplete(b_job_application_stage1);
14611  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_application_stage1)\n");
14612  #ifdef ERRCHECK
14613  if (rc != MB_SUCCESS)
14614  {
14615  fprintf(stderr, "ERROR: Could not complete sync of 'job_application_stage1' board\n");
14616  switch(rc) {
14617  case MB_ERR_INVALID:
14618  fprintf(stderr, "\t reason: 'job_application_stage1' board is invalid\n");
14619  break;
14620  case MB_ERR_MEMALLOC:
14621  fprintf(stderr, "\t reason: out of memory\n");
14622  break;
14623  case MB_ERR_INTERNAL:
14624  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14625  break;
14626  default:
14627  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
14628  break;
14629  }
14630 
14631 
14632  exit(rc);
14633  }
14634  #endif
14635 
14636 
14637 
14638  }
14639 
14640  /* If mb is not read then leave sync complete until last possible moment */
14641  if(FLAME_vacancy_stage1_message_board_read == 1)
14642  {
14643  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_vacancy_stage1)\n");
14644  rc = MB_SyncComplete(b_vacancy_stage1);
14645  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_vacancy_stage1)\n");
14646  #ifdef ERRCHECK
14647  if (rc != MB_SUCCESS)
14648  {
14649  fprintf(stderr, "ERROR: Could not complete sync of 'vacancy_stage1' board\n");
14650  switch(rc) {
14651  case MB_ERR_INVALID:
14652  fprintf(stderr, "\t reason: 'vacancy_stage1' board is invalid\n");
14653  break;
14654  case MB_ERR_MEMALLOC:
14655  fprintf(stderr, "\t reason: out of memory\n");
14656  break;
14657  case MB_ERR_INTERNAL:
14658  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14659  break;
14660  default:
14661  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
14662  break;
14663  }
14664 
14665 
14666  exit(rc);
14667  }
14668  #endif
14669 
14670 
14671 
14672  }
14673 
14674  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start jpoffice_labour_stage1\n");
14675  current_xmachine_jpoffice_holder = jpoffice_JPOLabourMarket_state->agents;
14676  while(current_xmachine_jpoffice_holder)
14677  {
14678  temp_xmachine_jpoffice_holder = current_xmachine_jpoffice_holder->next;
14679  current_xmachine_jpoffice = current_xmachine_jpoffice_holder->agent;
14680  current_xmachine_jpoffice_next_state = jpoffice_JPOLabourStage2_state;
14681  /* For backwards compatibility set current_xmachine */
14682  current_xmachine->xmachine_firm = NULL;
14683  current_xmachine->xmachine_household = NULL;
14684  current_xmachine->xmachine_equityfund = NULL;
14685  current_xmachine->xmachine_bank = NULL;
14686  current_xmachine->xmachine_government = NULL;
14687  current_xmachine->xmachine_centralbank = NULL;
14688  current_xmachine->xmachine_jpoffice = NULL;
14689  current_xmachine->xmachine_mall = NULL;
14690  current_xmachine->xmachine_reagency = NULL;
14691  current_xmachine->xmachine_jpoffice = current_xmachine_jpoffice;
14692 
14693  if(FLAME_condition_jpoffice_jpoffice_labour_stage1_JPOLabourMarket_JPOLabourStage2(current_xmachine_jpoffice)==1)
14694  {
14695 
14696 
14697 
14698 
14699 
14700  rc = MB_Iterator_CreateSorted(b_vacancy_stage1, &i_vacancy_stage1, &FLAME_sort_jpoffice_jpoffice_labour_stage1_JPOLabourMarket_JPOLabourStage2_vacancy_stage1);
14701 
14702  #ifdef ERRCHECK
14703  if (rc != MB_SUCCESS)
14704  {
14705  fprintf(stderr, "ERROR: Could not create Iterator for 'vacancy_stage1'\n");
14706  switch(rc) {
14707  case MB_ERR_INVALID:
14708  fprintf(stderr, "\t reason: 'vacancy_stage1' board is invalid\n");
14709  break;
14710  case MB_ERR_LOCKED:
14711  fprintf(stderr, "\t reason: 'vacancy_stage1' board is locked\n");
14712  break;
14713  case MB_ERR_MEMALLOC:
14714  fprintf(stderr, "\t reason: out of memory\n");
14715  break;
14716  case MB_ERR_INTERNAL:
14717  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14718  break;
14719  default:
14720 
14721 
14722  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
14723 
14724  break;
14725  }
14726 
14727 
14728  exit(rc);
14729  }
14730  #endif
14731 
14732 
14733 
14734 
14735 
14736  rc = MB_Iterator_CreateSorted(b_job_application_stage1, &i_job_application_stage1, &FLAME_sort_jpoffice_jpoffice_labour_stage1_JPOLabourMarket_JPOLabourStage2_job_application_stage1);
14737 
14738  #ifdef ERRCHECK
14739  if (rc != MB_SUCCESS)
14740  {
14741  fprintf(stderr, "ERROR: Could not create Iterator for 'job_application_stage1'\n");
14742  switch(rc) {
14743  case MB_ERR_INVALID:
14744  fprintf(stderr, "\t reason: 'job_application_stage1' board is invalid\n");
14745  break;
14746  case MB_ERR_LOCKED:
14747  fprintf(stderr, "\t reason: 'job_application_stage1' board is locked\n");
14748  break;
14749  case MB_ERR_MEMALLOC:
14750  fprintf(stderr, "\t reason: out of memory\n");
14751  break;
14752  case MB_ERR_INTERNAL:
14753  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14754  break;
14755  default:
14756 
14757 
14758  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
14759 
14760  break;
14761  }
14762 
14763 
14764  exit(rc);
14765  }
14766  #endif
14767 
14768 
14769 
14770  i = jpoffice_labour_stage1();
14771 
14772 
14773  rc = MB_Iterator_Delete(&i_vacancy_stage1);
14774  #ifdef ERRCHECK
14775  if (rc != MB_SUCCESS)
14776  {
14777  fprintf(stderr, "ERROR: Could not delete 'vacancy_stage1' iterator\n");
14778  switch(rc) {
14779  case MB_ERR_INVALID:
14780  fprintf(stderr, "\t reason: 'vacancy_stage1' iterator is invalid\n");
14781  break;
14782  case MB_ERR_INTERNAL:
14783  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14784  break;
14785  default:
14786  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
14787  break;
14788  }
14789 
14790 
14791  exit(rc);
14792  }
14793  #endif
14794 
14795  rc = MB_Iterator_Delete(&i_job_application_stage1);
14796  #ifdef ERRCHECK
14797  if (rc != MB_SUCCESS)
14798  {
14799  fprintf(stderr, "ERROR: Could not delete 'job_application_stage1' iterator\n");
14800  switch(rc) {
14801  case MB_ERR_INVALID:
14802  fprintf(stderr, "\t reason: 'job_application_stage1' iterator is invalid\n");
14803  break;
14804  case MB_ERR_INTERNAL:
14805  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14806  break;
14807  default:
14808  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
14809  break;
14810  }
14811 
14812 
14813  exit(rc);
14814  }
14815  #endif
14816 
14817 
14818  if(i == 1)
14819  {
14820  free_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_JPOLabourMarket_state);
14821  }
14822  else
14823  {
14824  transition_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_JPOLabourMarket_state, jpoffice_JPOLabourStage2_state);
14825  }
14826  }
14827 
14828  current_xmachine_jpoffice = NULL;
14829 
14830  current_xmachine_jpoffice_holder = temp_xmachine_jpoffice_holder;
14831  }
14832  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish jpoffice_labour_stage1\n");
14833 
14834  if(FLAME_job_match_stage1_message_board_write == 1)
14835  {
14836 
14837  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_match_stage1)\n");
14838  rc = MB_SyncStart(b_job_match_stage1);
14839  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_match_stage1)\n");
14840  #ifdef ERRCHECK
14841  if (rc != MB_SUCCESS)
14842  {
14843  fprintf(stderr, "ERROR: Could not start sync of 'job_match_stage1' board\n");
14844  switch(rc) {
14845  case MB_ERR_INVALID:
14846  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
14847  break;
14848  case MB_ERR_LOCKED:
14849  fprintf(stderr, "\t reason: 'job_match_stage1' board is locked\n");
14850  break;
14851  case MB_ERR_MEMALLOC:
14852  fprintf(stderr, "\t reason: out of memory\n");
14853  break;
14854  case MB_ERR_INTERNAL:
14855  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14856  break;
14857  default:
14858  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
14859  break;
14860  }
14861 
14862 
14863  exit(rc);
14864  }
14865  #endif
14866  }
14867 
14868 
14869 
14870 /* End of layer number 30 */
14871 
14872 /* Clear message boards that have finished being used
14873  * and sync complete if doing late sync complete */
14874 
14875 if(FLAME_vacancy_stage1_message_board_read == 0)
14876 {
14877  /*printf("%d> vacancy_stage1 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
14878 
14879  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_vacancy_stage1)\n");
14880  rc = MB_SyncComplete(b_vacancy_stage1);
14881  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_vacancy_stage1)\n");
14882  #ifdef ERRCHECK
14883  if (rc != MB_SUCCESS)
14884  {
14885  fprintf(stderr, "ERROR: Could not complete sync of 'vacancy_stage1' board\n");
14886  switch(rc) {
14887  case MB_ERR_INVALID:
14888  fprintf(stderr, "\t reason: 'vacancy_stage1' board is invalid\n");
14889  break;
14890  case MB_ERR_MEMALLOC:
14891  fprintf(stderr, "\t reason: out of memory\n");
14892  break;
14893  case MB_ERR_INTERNAL:
14894  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14895  break;
14896  default:
14897  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
14898  break;
14899  }
14900 
14901 
14902  exit(rc);
14903  }
14904  #endif
14905 }
14906 
14907  /* Delete any search trees */
14908 
14909  rc = MB_Clear(b_vacancy_stage1);
14910  #ifdef ERRCHECK
14911  if (rc != MB_SUCCESS)
14912  {
14913  fprintf(stderr, "ERROR: Could not clear 'vacancy_stage1' board\n");
14914  switch(rc) {
14915  case MB_ERR_INVALID:
14916  fprintf(stderr, "\t reason: 'vacancy_stage1' board is invalid\n");
14917  break;
14918  case MB_ERR_LOCKED:
14919  fprintf(stderr, "\t reason: 'vacancy_stage1' board is locked\n");
14920  break;
14921  case MB_ERR_INTERNAL:
14922  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14923  break;
14924  default:
14925  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
14926  break;
14927 
14928  }
14929 
14930 
14931  exit(rc);
14932  }
14933  #endif
14934 
14935 if(FLAME_job_application_stage1_message_board_read == 0)
14936 {
14937  /*printf("%d> job_application_stage1 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
14938 
14939  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_application_stage1)\n");
14940  rc = MB_SyncComplete(b_job_application_stage1);
14941  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_application_stage1)\n");
14942  #ifdef ERRCHECK
14943  if (rc != MB_SUCCESS)
14944  {
14945  fprintf(stderr, "ERROR: Could not complete sync of 'job_application_stage1' board\n");
14946  switch(rc) {
14947  case MB_ERR_INVALID:
14948  fprintf(stderr, "\t reason: 'job_application_stage1' board is invalid\n");
14949  break;
14950  case MB_ERR_MEMALLOC:
14951  fprintf(stderr, "\t reason: out of memory\n");
14952  break;
14953  case MB_ERR_INTERNAL:
14954  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14955  break;
14956  default:
14957  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
14958  break;
14959  }
14960 
14961 
14962  exit(rc);
14963  }
14964  #endif
14965 }
14966 
14967  /* Delete any search trees */
14968 
14969  rc = MB_Clear(b_job_application_stage1);
14970  #ifdef ERRCHECK
14971  if (rc != MB_SUCCESS)
14972  {
14973  fprintf(stderr, "ERROR: Could not clear 'job_application_stage1' board\n");
14974  switch(rc) {
14975  case MB_ERR_INVALID:
14976  fprintf(stderr, "\t reason: 'job_application_stage1' board is invalid\n");
14977  break;
14978  case MB_ERR_LOCKED:
14979  fprintf(stderr, "\t reason: 'job_application_stage1' board is locked\n");
14980  break;
14981  case MB_ERR_INTERNAL:
14982  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
14983  break;
14984  default:
14985  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
14986  break;
14987 
14988  }
14989 
14990 
14991  exit(rc);
14992  }
14993  #endif
14994 
14995 
14996  /* If mb is not read then leave sync complete until last possible moment */
14997  if(FLAME_job_match_stage1_message_board_read == 1)
14998  {
14999  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_match_stage1)\n");
15000  rc = MB_SyncComplete(b_job_match_stage1);
15001  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_match_stage1)\n");
15002  #ifdef ERRCHECK
15003  if (rc != MB_SUCCESS)
15004  {
15005  fprintf(stderr, "ERROR: Could not complete sync of 'job_match_stage1' board\n");
15006  switch(rc) {
15007  case MB_ERR_INVALID:
15008  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
15009  break;
15010  case MB_ERR_MEMALLOC:
15011  fprintf(stderr, "\t reason: out of memory\n");
15012  break;
15013  case MB_ERR_INTERNAL:
15014  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15015  break;
15016  default:
15017  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
15018  break;
15019  }
15020 
15021 
15022  exit(rc);
15023  }
15024  #endif
15025 
15026 
15027 
15028  }
15029 
15030  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_labour_turnover\n");
15031  current_xmachine_household_holder = household_HHLabourStage2_state->agents;
15032  while(current_xmachine_household_holder)
15033  {
15034  temp_xmachine_household_holder = current_xmachine_household_holder->next;
15035  current_xmachine_household = current_xmachine_household_holder->agent;
15036  current_xmachine_household_next_state = household_HHLabourEmploymentStatus_state;
15037  /* For backwards compatibility set current_xmachine */
15038  current_xmachine->xmachine_firm = NULL;
15039  current_xmachine->xmachine_household = NULL;
15040  current_xmachine->xmachine_equityfund = NULL;
15041  current_xmachine->xmachine_bank = NULL;
15042  current_xmachine->xmachine_government = NULL;
15043  current_xmachine->xmachine_centralbank = NULL;
15044  current_xmachine->xmachine_jpoffice = NULL;
15045  current_xmachine->xmachine_mall = NULL;
15046  current_xmachine->xmachine_reagency = NULL;
15047  current_xmachine->xmachine_household = current_xmachine_household;
15048 
15049 
15050 
15051 
15052 
15053 
15054 
15055 
15056  rc = MB_Iterator_CreateFiltered(b_job_match_stage1, &i_job_match_stage1, &FLAME_filter_household_household_labour_turnover_HHLabourStage2_HHLabourEmploymentStatus_job_match_stage1, current_xmachine_household);
15057 
15058 
15059 
15060  #ifdef ERRCHECK
15061  if (rc != MB_SUCCESS)
15062  {
15063  fprintf(stderr, "ERROR: Could not create Iterator for 'job_match_stage1'\n");
15064  switch(rc) {
15065  case MB_ERR_INVALID:
15066  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
15067  break;
15068  case MB_ERR_LOCKED:
15069  fprintf(stderr, "\t reason: 'job_match_stage1' board is locked\n");
15070  break;
15071  case MB_ERR_MEMALLOC:
15072  fprintf(stderr, "\t reason: out of memory\n");
15073  break;
15074  case MB_ERR_INTERNAL:
15075  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15076  break;
15077  default:
15078 
15079  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
15080 
15081 
15082  break;
15083  }
15084 
15085 
15086  exit(rc);
15087  }
15088  #endif
15089 
15090 
15091 
15092  i = household_labour_turnover();
15093 
15094 
15095  rc = MB_Iterator_Delete(&i_job_match_stage1);
15096  #ifdef ERRCHECK
15097  if (rc != MB_SUCCESS)
15098  {
15099  fprintf(stderr, "ERROR: Could not delete 'job_match_stage1' iterator\n");
15100  switch(rc) {
15101  case MB_ERR_INVALID:
15102  fprintf(stderr, "\t reason: 'job_match_stage1' iterator is invalid\n");
15103  break;
15104  case MB_ERR_INTERNAL:
15105  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15106  break;
15107  default:
15108  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
15109  break;
15110  }
15111 
15112 
15113  exit(rc);
15114  }
15115  #endif
15116 
15117 
15118  if(i == 1)
15119  {
15120  free_household_agent(current_xmachine_household_holder, household_HHLabourStage2_state);
15121  }
15122  else
15123  {
15124  transition_household_agent(current_xmachine_household_holder, household_HHLabourStage2_state, household_HHLabourEmploymentStatus_state);
15125  }
15126 
15127 
15128  current_xmachine_household = NULL;
15129 
15130  current_xmachine_household_holder = temp_xmachine_household_holder;
15131  }
15132  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_labour_turnover\n");
15133 
15134  if(FLAME_job_change_message_board_write == 1)
15135  {
15136 
15137  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_change)\n");
15138  rc = MB_SyncStart(b_job_change);
15139  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_change)\n");
15140  #ifdef ERRCHECK
15141  if (rc != MB_SUCCESS)
15142  {
15143  fprintf(stderr, "ERROR: Could not start sync of 'job_change' board\n");
15144  switch(rc) {
15145  case MB_ERR_INVALID:
15146  fprintf(stderr, "\t reason: 'job_change' board is invalid\n");
15147  break;
15148  case MB_ERR_LOCKED:
15149  fprintf(stderr, "\t reason: 'job_change' board is locked\n");
15150  break;
15151  case MB_ERR_MEMALLOC:
15152  fprintf(stderr, "\t reason: out of memory\n");
15153  break;
15154  case MB_ERR_INTERNAL:
15155  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15156  break;
15157  default:
15158  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
15159  break;
15160  }
15161 
15162 
15163  exit(rc);
15164  }
15165  #endif
15166  }
15167 
15168 
15169 
15170  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_job_offer_stage1\n");
15171  current_xmachine_firm_holder = firm_FirmLabourStage1Application_state->agents;
15172  while(current_xmachine_firm_holder)
15173  {
15174  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
15175  current_xmachine_firm = current_xmachine_firm_holder->agent;
15176  current_xmachine_firm_next_state = firm_FirmLabourStage1End_state;
15177  /* For backwards compatibility set current_xmachine */
15178  current_xmachine->xmachine_firm = NULL;
15179  current_xmachine->xmachine_household = NULL;
15180  current_xmachine->xmachine_equityfund = NULL;
15181  current_xmachine->xmachine_bank = NULL;
15182  current_xmachine->xmachine_government = NULL;
15183  current_xmachine->xmachine_centralbank = NULL;
15184  current_xmachine->xmachine_jpoffice = NULL;
15185  current_xmachine->xmachine_mall = NULL;
15186  current_xmachine->xmachine_reagency = NULL;
15187  current_xmachine->xmachine_firm = current_xmachine_firm;
15188 
15189 
15190 
15191 
15192 
15193 
15194 
15195 
15196  rc = MB_Iterator_CreateFiltered(b_job_match_stage1, &i_job_match_stage1, &FLAME_filter_firm_firm_labour_job_offer_stage1_FirmLabourStage1Application_FirmLabourStage1End_job_match_stage1, current_xmachine_firm);
15197 
15198 
15199 
15200  #ifdef ERRCHECK
15201  if (rc != MB_SUCCESS)
15202  {
15203  fprintf(stderr, "ERROR: Could not create Iterator for 'job_match_stage1'\n");
15204  switch(rc) {
15205  case MB_ERR_INVALID:
15206  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
15207  break;
15208  case MB_ERR_LOCKED:
15209  fprintf(stderr, "\t reason: 'job_match_stage1' board is locked\n");
15210  break;
15211  case MB_ERR_MEMALLOC:
15212  fprintf(stderr, "\t reason: out of memory\n");
15213  break;
15214  case MB_ERR_INTERNAL:
15215  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15216  break;
15217  default:
15218 
15219  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
15220 
15221 
15222  break;
15223  }
15224 
15225 
15226  exit(rc);
15227  }
15228  #endif
15229 
15230 
15231 
15232  i = firm_labour_job_offer_stage1();
15233 
15234 
15235  rc = MB_Iterator_Delete(&i_job_match_stage1);
15236  #ifdef ERRCHECK
15237  if (rc != MB_SUCCESS)
15238  {
15239  fprintf(stderr, "ERROR: Could not delete 'job_match_stage1' iterator\n");
15240  switch(rc) {
15241  case MB_ERR_INVALID:
15242  fprintf(stderr, "\t reason: 'job_match_stage1' iterator is invalid\n");
15243  break;
15244  case MB_ERR_INTERNAL:
15245  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15246  break;
15247  default:
15248  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
15249  break;
15250  }
15251 
15252 
15253  exit(rc);
15254  }
15255  #endif
15256 
15257 
15258  if(i == 1)
15259  {
15260  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1Application_state);
15261  }
15262  else
15263  {
15264  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1Application_state, firm_FirmLabourStage1End_state);
15265  }
15266 
15267 
15268  current_xmachine_firm = NULL;
15269 
15270  current_xmachine_firm_holder = temp_xmachine_firm_holder;
15271  }
15272  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_job_offer_stage1\n");
15273 
15274 
15275 /* End of layer number 31 */
15276 
15277 /* Clear message boards that have finished being used
15278  * and sync complete if doing late sync complete */
15279 
15280 if(FLAME_job_match_stage1_message_board_read == 0)
15281 {
15282  /*printf("%d> job_match_stage1 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
15283 
15284  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_match_stage1)\n");
15285  rc = MB_SyncComplete(b_job_match_stage1);
15286  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_match_stage1)\n");
15287  #ifdef ERRCHECK
15288  if (rc != MB_SUCCESS)
15289  {
15290  fprintf(stderr, "ERROR: Could not complete sync of 'job_match_stage1' board\n");
15291  switch(rc) {
15292  case MB_ERR_INVALID:
15293  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
15294  break;
15295  case MB_ERR_MEMALLOC:
15296  fprintf(stderr, "\t reason: out of memory\n");
15297  break;
15298  case MB_ERR_INTERNAL:
15299  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15300  break;
15301  default:
15302  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
15303  break;
15304  }
15305 
15306 
15307  exit(rc);
15308  }
15309  #endif
15310 }
15311 
15312  /* Delete any search trees */
15313 
15314  rc = MB_Clear(b_job_match_stage1);
15315  #ifdef ERRCHECK
15316  if (rc != MB_SUCCESS)
15317  {
15318  fprintf(stderr, "ERROR: Could not clear 'job_match_stage1' board\n");
15319  switch(rc) {
15320  case MB_ERR_INVALID:
15321  fprintf(stderr, "\t reason: 'job_match_stage1' board is invalid\n");
15322  break;
15323  case MB_ERR_LOCKED:
15324  fprintf(stderr, "\t reason: 'job_match_stage1' board is locked\n");
15325  break;
15326  case MB_ERR_INTERNAL:
15327  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15328  break;
15329  default:
15330  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
15331  break;
15332 
15333  }
15334 
15335 
15336  exit(rc);
15337  }
15338  #endif
15339 
15340 
15341  /* If mb is not read then leave sync complete until last possible moment */
15342  if(FLAME_job_change_message_board_read == 1)
15343  {
15344  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_change)\n");
15345  rc = MB_SyncComplete(b_job_change);
15346  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_change)\n");
15347  #ifdef ERRCHECK
15348  if (rc != MB_SUCCESS)
15349  {
15350  fprintf(stderr, "ERROR: Could not complete sync of 'job_change' board\n");
15351  switch(rc) {
15352  case MB_ERR_INVALID:
15353  fprintf(stderr, "\t reason: 'job_change' board is invalid\n");
15354  break;
15355  case MB_ERR_MEMALLOC:
15356  fprintf(stderr, "\t reason: out of memory\n");
15357  break;
15358  case MB_ERR_INTERNAL:
15359  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15360  break;
15361  default:
15362  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
15363  break;
15364  }
15365 
15366 
15367  exit(rc);
15368  }
15369  #endif
15370 
15371 
15372 
15373  }
15374 
15375  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_update\n");
15376  current_xmachine_firm_holder = firm_FirmLabourStage1End_state->agents;
15377  while(current_xmachine_firm_holder)
15378  {
15379  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
15380  current_xmachine_firm = current_xmachine_firm_holder->agent;
15381  current_xmachine_firm_next_state = firm_FirmLabourStage2_state;
15382  /* For backwards compatibility set current_xmachine */
15383  current_xmachine->xmachine_firm = NULL;
15384  current_xmachine->xmachine_household = NULL;
15385  current_xmachine->xmachine_equityfund = NULL;
15386  current_xmachine->xmachine_bank = NULL;
15387  current_xmachine->xmachine_government = NULL;
15388  current_xmachine->xmachine_centralbank = NULL;
15389  current_xmachine->xmachine_jpoffice = NULL;
15390  current_xmachine->xmachine_mall = NULL;
15391  current_xmachine->xmachine_reagency = NULL;
15392  current_xmachine->xmachine_firm = current_xmachine_firm;
15393 
15394 
15395 
15396 
15397 
15398 
15399 
15400 
15401  rc = MB_Iterator_CreateFiltered(b_job_change, &i_job_change, &FLAME_filter_firm_firm_labour_update_FirmLabourStage1End_FirmLabourStage2_job_change, current_xmachine_firm);
15402 
15403 
15404 
15405  #ifdef ERRCHECK
15406  if (rc != MB_SUCCESS)
15407  {
15408  fprintf(stderr, "ERROR: Could not create Iterator for 'job_change'\n");
15409  switch(rc) {
15410  case MB_ERR_INVALID:
15411  fprintf(stderr, "\t reason: 'job_change' board is invalid\n");
15412  break;
15413  case MB_ERR_LOCKED:
15414  fprintf(stderr, "\t reason: 'job_change' board is locked\n");
15415  break;
15416  case MB_ERR_MEMALLOC:
15417  fprintf(stderr, "\t reason: out of memory\n");
15418  break;
15419  case MB_ERR_INTERNAL:
15420  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15421  break;
15422  default:
15423 
15424  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
15425 
15426 
15427  break;
15428  }
15429 
15430 
15431  exit(rc);
15432  }
15433  #endif
15434 
15435 
15436 
15437  i = firm_labour_update();
15438 
15439 
15440  rc = MB_Iterator_Delete(&i_job_change);
15441  #ifdef ERRCHECK
15442  if (rc != MB_SUCCESS)
15443  {
15444  fprintf(stderr, "ERROR: Could not delete 'job_change' iterator\n");
15445  switch(rc) {
15446  case MB_ERR_INVALID:
15447  fprintf(stderr, "\t reason: 'job_change' iterator is invalid\n");
15448  break;
15449  case MB_ERR_INTERNAL:
15450  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15451  break;
15452  default:
15453  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
15454  break;
15455  }
15456 
15457 
15458  exit(rc);
15459  }
15460  #endif
15461 
15462 
15463  if(i == 1)
15464  {
15465  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1End_state);
15466  }
15467  else
15468  {
15469  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage1End_state, firm_FirmLabourStage2_state);
15470  }
15471 
15472 
15473  current_xmachine_firm = NULL;
15474 
15475  current_xmachine_firm_holder = temp_xmachine_firm_holder;
15476  }
15477  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_update\n");
15478 
15479 
15480 /* End of layer number 32 */
15481 
15482 /* Clear message boards that have finished being used
15483  * and sync complete if doing late sync complete */
15484 
15485 if(FLAME_job_change_message_board_read == 0)
15486 {
15487  /*printf("%d> job_change message board sync complete late as no agents reading any messages of this type\n", node_number);*/
15488 
15489  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_change)\n");
15490  rc = MB_SyncComplete(b_job_change);
15491  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_change)\n");
15492  #ifdef ERRCHECK
15493  if (rc != MB_SUCCESS)
15494  {
15495  fprintf(stderr, "ERROR: Could not complete sync of 'job_change' board\n");
15496  switch(rc) {
15497  case MB_ERR_INVALID:
15498  fprintf(stderr, "\t reason: 'job_change' board is invalid\n");
15499  break;
15500  case MB_ERR_MEMALLOC:
15501  fprintf(stderr, "\t reason: out of memory\n");
15502  break;
15503  case MB_ERR_INTERNAL:
15504  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15505  break;
15506  default:
15507  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
15508  break;
15509  }
15510 
15511 
15512  exit(rc);
15513  }
15514  #endif
15515 }
15516 
15517  /* Delete any search trees */
15518 
15519  rc = MB_Clear(b_job_change);
15520  #ifdef ERRCHECK
15521  if (rc != MB_SUCCESS)
15522  {
15523  fprintf(stderr, "ERROR: Could not clear 'job_change' board\n");
15524  switch(rc) {
15525  case MB_ERR_INVALID:
15526  fprintf(stderr, "\t reason: 'job_change' board is invalid\n");
15527  break;
15528  case MB_ERR_LOCKED:
15529  fprintf(stderr, "\t reason: 'job_change' board is locked\n");
15530  break;
15531  case MB_ERR_INTERNAL:
15532  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15533  break;
15534  default:
15535  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
15536  break;
15537 
15538  }
15539 
15540 
15541  exit(rc);
15542  }
15543  #endif
15544 
15545  /* DEBUG: States with branching functions */
15546  current_xmachine_firm_holder = firm_FirmLabourStage2_state->agents;
15547  while(current_xmachine_firm_holder)
15548  {
15549  FLAME_debug_count = 0;
15550  /* Function: idle */
15551  if(FLAME_condition_firm_idle_FirmLabourStage2_FirmLabourPayWages(current_xmachine_firm_holder->agent)==1)
15552  { FLAME_debug_count++; }
15553  /* Function: firm_labour_job_announcement_stage2 */
15554  if(FLAME_condition_firm_firm_labour_job_announcement_stage2_FirmLabourStage2_FirmLabourStage2End(current_xmachine_firm_holder->agent)==1)
15555  { FLAME_debug_count++; }
15556  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
15557  if(FLAME_debug_count != 1)
15558  {
15559  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmLabourStage2'\n");
15560  if(FLAME_debug_count > 1)
15561  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
15562  if(FLAME_debug_count == 0)
15563  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
15564  }
15565 
15566  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
15567  }
15568 
15569  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_job_announcement_stage2\n");
15570  current_xmachine_firm_holder = firm_FirmLabourStage2_state->agents;
15571  while(current_xmachine_firm_holder)
15572  {
15573  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
15574  current_xmachine_firm = current_xmachine_firm_holder->agent;
15575  current_xmachine_firm_next_state = firm_FirmLabourStage2End_state;
15576  /* For backwards compatibility set current_xmachine */
15577  current_xmachine->xmachine_firm = NULL;
15578  current_xmachine->xmachine_household = NULL;
15579  current_xmachine->xmachine_equityfund = NULL;
15580  current_xmachine->xmachine_bank = NULL;
15581  current_xmachine->xmachine_government = NULL;
15582  current_xmachine->xmachine_centralbank = NULL;
15583  current_xmachine->xmachine_jpoffice = NULL;
15584  current_xmachine->xmachine_mall = NULL;
15585  current_xmachine->xmachine_reagency = NULL;
15586  current_xmachine->xmachine_firm = current_xmachine_firm;
15587 
15588  if(FLAME_condition_firm_firm_labour_job_announcement_stage2_FirmLabourStage2_FirmLabourStage2End(current_xmachine_firm)==1)
15589  {
15590 
15591 
15592 
15593  i = firm_labour_job_announcement_stage2();
15594 
15595 
15596 
15597  if(i == 1)
15598  {
15599  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage2_state);
15600  }
15601  else
15602  {
15603  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage2_state, firm_FirmLabourStage2End_state);
15604  }
15605  }
15606 
15607  current_xmachine_firm = NULL;
15608 
15609  current_xmachine_firm_holder = temp_xmachine_firm_holder;
15610  }
15611  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_job_announcement_stage2\n");
15612 
15613  if(FLAME_vacancy_stage2_message_board_write == 1)
15614  {
15615 
15616  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_vacancy_stage2)\n");
15617  rc = MB_SyncStart(b_vacancy_stage2);
15618  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_vacancy_stage2)\n");
15619  #ifdef ERRCHECK
15620  if (rc != MB_SUCCESS)
15621  {
15622  fprintf(stderr, "ERROR: Could not start sync of 'vacancy_stage2' board\n");
15623  switch(rc) {
15624  case MB_ERR_INVALID:
15625  fprintf(stderr, "\t reason: 'vacancy_stage2' board is invalid\n");
15626  break;
15627  case MB_ERR_LOCKED:
15628  fprintf(stderr, "\t reason: 'vacancy_stage2' board is locked\n");
15629  break;
15630  case MB_ERR_MEMALLOC:
15631  fprintf(stderr, "\t reason: out of memory\n");
15632  break;
15633  case MB_ERR_INTERNAL:
15634  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15635  break;
15636  default:
15637  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
15638  break;
15639  }
15640 
15641 
15642  exit(rc);
15643  }
15644  #endif
15645  }
15646 
15647 
15648 
15649  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
15650  current_xmachine_firm_holder = firm_FirmLabourStage2_state->agents;
15651  while(current_xmachine_firm_holder)
15652  {
15653  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
15654  current_xmachine_firm = current_xmachine_firm_holder->agent;
15655  current_xmachine_firm_next_state = firm_FirmLabourPayWages_state;
15656  /* For backwards compatibility set current_xmachine */
15657  current_xmachine->xmachine_firm = NULL;
15658  current_xmachine->xmachine_household = NULL;
15659  current_xmachine->xmachine_equityfund = NULL;
15660  current_xmachine->xmachine_bank = NULL;
15661  current_xmachine->xmachine_government = NULL;
15662  current_xmachine->xmachine_centralbank = NULL;
15663  current_xmachine->xmachine_jpoffice = NULL;
15664  current_xmachine->xmachine_mall = NULL;
15665  current_xmachine->xmachine_reagency = NULL;
15666  current_xmachine->xmachine_firm = current_xmachine_firm;
15667 
15668  if(FLAME_condition_firm_idle_FirmLabourStage2_FirmLabourPayWages(current_xmachine_firm)==1)
15669  {
15670 
15671 
15672 
15673  i = idle();
15674 
15675 
15676 
15677  if(i == 1)
15678  {
15679  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage2_state);
15680  }
15681  else
15682  {
15683  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage2_state, firm_FirmLabourPayWages_state);
15684  }
15685  }
15686 
15687  current_xmachine_firm = NULL;
15688 
15689  current_xmachine_firm_holder = temp_xmachine_firm_holder;
15690  }
15691  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
15692 
15693 
15694 /* End of layer number 33 */
15695 
15696 /* Clear message boards that have finished being used
15697  * and sync complete if doing late sync complete */
15698 
15699 
15700  /* If mb is not read then leave sync complete until last possible moment */
15701  if(FLAME_vacancy_stage2_message_board_read == 1)
15702  {
15703  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_vacancy_stage2)\n");
15704  rc = MB_SyncComplete(b_vacancy_stage2);
15705  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_vacancy_stage2)\n");
15706  #ifdef ERRCHECK
15707  if (rc != MB_SUCCESS)
15708  {
15709  fprintf(stderr, "ERROR: Could not complete sync of 'vacancy_stage2' board\n");
15710  switch(rc) {
15711  case MB_ERR_INVALID:
15712  fprintf(stderr, "\t reason: 'vacancy_stage2' board is invalid\n");
15713  break;
15714  case MB_ERR_MEMALLOC:
15715  fprintf(stderr, "\t reason: out of memory\n");
15716  break;
15717  case MB_ERR_INTERNAL:
15718  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15719  break;
15720  default:
15721  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
15722  break;
15723  }
15724 
15725 
15726  exit(rc);
15727  }
15728  #endif
15729 
15730 
15731 
15732  }
15733 
15734  /* If mb is not read then leave sync complete until last possible moment */
15735  if(FLAME_job_application_stage2_message_board_read == 1)
15736  {
15737  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_application_stage2)\n");
15738  rc = MB_SyncComplete(b_job_application_stage2);
15739  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_application_stage2)\n");
15740  #ifdef ERRCHECK
15741  if (rc != MB_SUCCESS)
15742  {
15743  fprintf(stderr, "ERROR: Could not complete sync of 'job_application_stage2' board\n");
15744  switch(rc) {
15745  case MB_ERR_INVALID:
15746  fprintf(stderr, "\t reason: 'job_application_stage2' board is invalid\n");
15747  break;
15748  case MB_ERR_MEMALLOC:
15749  fprintf(stderr, "\t reason: out of memory\n");
15750  break;
15751  case MB_ERR_INTERNAL:
15752  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15753  break;
15754  default:
15755  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
15756  break;
15757  }
15758 
15759 
15760  exit(rc);
15761  }
15762  #endif
15763 
15764 
15765 
15766  }
15767 
15768  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start jpoffice_labour_stage2\n");
15769  current_xmachine_jpoffice_holder = jpoffice_JPOLabourStage2_state->agents;
15770  while(current_xmachine_jpoffice_holder)
15771  {
15772  temp_xmachine_jpoffice_holder = current_xmachine_jpoffice_holder->next;
15773  current_xmachine_jpoffice = current_xmachine_jpoffice_holder->agent;
15774  current_xmachine_jpoffice_next_state = jpoffice_end_state;
15775  /* For backwards compatibility set current_xmachine */
15776  current_xmachine->xmachine_firm = NULL;
15777  current_xmachine->xmachine_household = NULL;
15778  current_xmachine->xmachine_equityfund = NULL;
15779  current_xmachine->xmachine_bank = NULL;
15780  current_xmachine->xmachine_government = NULL;
15781  current_xmachine->xmachine_centralbank = NULL;
15782  current_xmachine->xmachine_jpoffice = NULL;
15783  current_xmachine->xmachine_mall = NULL;
15784  current_xmachine->xmachine_reagency = NULL;
15785  current_xmachine->xmachine_jpoffice = current_xmachine_jpoffice;
15786 
15787 
15788 
15789 
15790 
15791 
15792 
15793  rc = MB_Iterator_CreateSorted(b_vacancy_stage2, &i_vacancy_stage2, &FLAME_sort_jpoffice_jpoffice_labour_stage2_JPOLabourStage2_end_vacancy_stage2);
15794 
15795  #ifdef ERRCHECK
15796  if (rc != MB_SUCCESS)
15797  {
15798  fprintf(stderr, "ERROR: Could not create Iterator for 'vacancy_stage2'\n");
15799  switch(rc) {
15800  case MB_ERR_INVALID:
15801  fprintf(stderr, "\t reason: 'vacancy_stage2' board is invalid\n");
15802  break;
15803  case MB_ERR_LOCKED:
15804  fprintf(stderr, "\t reason: 'vacancy_stage2' board is locked\n");
15805  break;
15806  case MB_ERR_MEMALLOC:
15807  fprintf(stderr, "\t reason: out of memory\n");
15808  break;
15809  case MB_ERR_INTERNAL:
15810  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15811  break;
15812  default:
15813 
15814 
15815  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
15816 
15817  break;
15818  }
15819 
15820 
15821  exit(rc);
15822  }
15823  #endif
15824 
15825 
15826 
15827 
15828 
15829  rc = MB_Iterator_CreateSorted(b_job_application_stage2, &i_job_application_stage2, &FLAME_sort_jpoffice_jpoffice_labour_stage2_JPOLabourStage2_end_job_application_stage2);
15830 
15831  #ifdef ERRCHECK
15832  if (rc != MB_SUCCESS)
15833  {
15834  fprintf(stderr, "ERROR: Could not create Iterator for 'job_application_stage2'\n");
15835  switch(rc) {
15836  case MB_ERR_INVALID:
15837  fprintf(stderr, "\t reason: 'job_application_stage2' board is invalid\n");
15838  break;
15839  case MB_ERR_LOCKED:
15840  fprintf(stderr, "\t reason: 'job_application_stage2' board is locked\n");
15841  break;
15842  case MB_ERR_MEMALLOC:
15843  fprintf(stderr, "\t reason: out of memory\n");
15844  break;
15845  case MB_ERR_INTERNAL:
15846  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15847  break;
15848  default:
15849 
15850 
15851  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
15852 
15853  break;
15854  }
15855 
15856 
15857  exit(rc);
15858  }
15859  #endif
15860 
15861 
15862 
15863  i = jpoffice_labour_stage2();
15864 
15865 
15866  rc = MB_Iterator_Delete(&i_vacancy_stage2);
15867  #ifdef ERRCHECK
15868  if (rc != MB_SUCCESS)
15869  {
15870  fprintf(stderr, "ERROR: Could not delete 'vacancy_stage2' iterator\n");
15871  switch(rc) {
15872  case MB_ERR_INVALID:
15873  fprintf(stderr, "\t reason: 'vacancy_stage2' iterator is invalid\n");
15874  break;
15875  case MB_ERR_INTERNAL:
15876  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15877  break;
15878  default:
15879  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
15880  break;
15881  }
15882 
15883 
15884  exit(rc);
15885  }
15886  #endif
15887 
15888  rc = MB_Iterator_Delete(&i_job_application_stage2);
15889  #ifdef ERRCHECK
15890  if (rc != MB_SUCCESS)
15891  {
15892  fprintf(stderr, "ERROR: Could not delete 'job_application_stage2' iterator\n");
15893  switch(rc) {
15894  case MB_ERR_INVALID:
15895  fprintf(stderr, "\t reason: 'job_application_stage2' iterator is invalid\n");
15896  break;
15897  case MB_ERR_INTERNAL:
15898  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15899  break;
15900  default:
15901  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
15902  break;
15903  }
15904 
15905 
15906  exit(rc);
15907  }
15908  #endif
15909 
15910 
15911  if(i == 1)
15912  {
15913  free_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_JPOLabourStage2_state);
15914  }
15915  else
15916  {
15917  transition_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_JPOLabourStage2_state, jpoffice_end_state);
15918  }
15919 
15920 
15921  current_xmachine_jpoffice = NULL;
15922 
15923  current_xmachine_jpoffice_holder = temp_xmachine_jpoffice_holder;
15924  }
15925  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish jpoffice_labour_stage2\n");
15926 
15927  if(FLAME_job_match_stage2_message_board_write == 1)
15928  {
15929 
15930  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_job_match_stage2)\n");
15931  rc = MB_SyncStart(b_job_match_stage2);
15932  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_job_match_stage2)\n");
15933  #ifdef ERRCHECK
15934  if (rc != MB_SUCCESS)
15935  {
15936  fprintf(stderr, "ERROR: Could not start sync of 'job_match_stage2' board\n");
15937  switch(rc) {
15938  case MB_ERR_INVALID:
15939  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
15940  break;
15941  case MB_ERR_LOCKED:
15942  fprintf(stderr, "\t reason: 'job_match_stage2' board is locked\n");
15943  break;
15944  case MB_ERR_MEMALLOC:
15945  fprintf(stderr, "\t reason: out of memory\n");
15946  break;
15947  case MB_ERR_INTERNAL:
15948  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15949  break;
15950  default:
15951  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
15952  break;
15953  }
15954 
15955 
15956  exit(rc);
15957  }
15958  #endif
15959  }
15960 
15961 
15962 
15963 /* End of layer number 34 */
15964 
15965 /* Clear message boards that have finished being used
15966  * and sync complete if doing late sync complete */
15967 
15968 if(FLAME_job_application_stage2_message_board_read == 0)
15969 {
15970  /*printf("%d> job_application_stage2 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
15971 
15972  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_application_stage2)\n");
15973  rc = MB_SyncComplete(b_job_application_stage2);
15974  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_application_stage2)\n");
15975  #ifdef ERRCHECK
15976  if (rc != MB_SUCCESS)
15977  {
15978  fprintf(stderr, "ERROR: Could not complete sync of 'job_application_stage2' board\n");
15979  switch(rc) {
15980  case MB_ERR_INVALID:
15981  fprintf(stderr, "\t reason: 'job_application_stage2' board is invalid\n");
15982  break;
15983  case MB_ERR_MEMALLOC:
15984  fprintf(stderr, "\t reason: out of memory\n");
15985  break;
15986  case MB_ERR_INTERNAL:
15987  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
15988  break;
15989  default:
15990  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
15991  break;
15992  }
15993 
15994 
15995  exit(rc);
15996  }
15997  #endif
15998 }
15999 
16000  /* Delete any search trees */
16001 
16002  rc = MB_Clear(b_job_application_stage2);
16003  #ifdef ERRCHECK
16004  if (rc != MB_SUCCESS)
16005  {
16006  fprintf(stderr, "ERROR: Could not clear 'job_application_stage2' board\n");
16007  switch(rc) {
16008  case MB_ERR_INVALID:
16009  fprintf(stderr, "\t reason: 'job_application_stage2' board is invalid\n");
16010  break;
16011  case MB_ERR_LOCKED:
16012  fprintf(stderr, "\t reason: 'job_application_stage2' board is locked\n");
16013  break;
16014  case MB_ERR_INTERNAL:
16015  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16016  break;
16017  default:
16018  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
16019  break;
16020 
16021  }
16022 
16023 
16024  exit(rc);
16025  }
16026  #endif
16027 
16028 if(FLAME_vacancy_stage2_message_board_read == 0)
16029 {
16030  /*printf("%d> vacancy_stage2 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
16031 
16032  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_vacancy_stage2)\n");
16033  rc = MB_SyncComplete(b_vacancy_stage2);
16034  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_vacancy_stage2)\n");
16035  #ifdef ERRCHECK
16036  if (rc != MB_SUCCESS)
16037  {
16038  fprintf(stderr, "ERROR: Could not complete sync of 'vacancy_stage2' board\n");
16039  switch(rc) {
16040  case MB_ERR_INVALID:
16041  fprintf(stderr, "\t reason: 'vacancy_stage2' board is invalid\n");
16042  break;
16043  case MB_ERR_MEMALLOC:
16044  fprintf(stderr, "\t reason: out of memory\n");
16045  break;
16046  case MB_ERR_INTERNAL:
16047  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16048  break;
16049  default:
16050  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
16051  break;
16052  }
16053 
16054 
16055  exit(rc);
16056  }
16057  #endif
16058 }
16059 
16060  /* Delete any search trees */
16061 
16062  rc = MB_Clear(b_vacancy_stage2);
16063  #ifdef ERRCHECK
16064  if (rc != MB_SUCCESS)
16065  {
16066  fprintf(stderr, "ERROR: Could not clear 'vacancy_stage2' board\n");
16067  switch(rc) {
16068  case MB_ERR_INVALID:
16069  fprintf(stderr, "\t reason: 'vacancy_stage2' board is invalid\n");
16070  break;
16071  case MB_ERR_LOCKED:
16072  fprintf(stderr, "\t reason: 'vacancy_stage2' board is locked\n");
16073  break;
16074  case MB_ERR_INTERNAL:
16075  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16076  break;
16077  default:
16078  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
16079  break;
16080 
16081  }
16082 
16083 
16084  exit(rc);
16085  }
16086  #endif
16087 
16088 
16089  /* If mb is not read then leave sync complete until last possible moment */
16090  if(FLAME_job_match_stage2_message_board_read == 1)
16091  {
16092  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_match_stage2)\n");
16093  rc = MB_SyncComplete(b_job_match_stage2);
16094  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_match_stage2)\n");
16095  #ifdef ERRCHECK
16096  if (rc != MB_SUCCESS)
16097  {
16098  fprintf(stderr, "ERROR: Could not complete sync of 'job_match_stage2' board\n");
16099  switch(rc) {
16100  case MB_ERR_INVALID:
16101  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
16102  break;
16103  case MB_ERR_MEMALLOC:
16104  fprintf(stderr, "\t reason: out of memory\n");
16105  break;
16106  case MB_ERR_INTERNAL:
16107  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16108  break;
16109  default:
16110  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
16111  break;
16112  }
16113 
16114 
16115  exit(rc);
16116  }
16117  #endif
16118 
16119 
16120 
16121  }
16122 
16123  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_job_offer_stage2\n");
16124  current_xmachine_firm_holder = firm_FirmLabourStage2End_state->agents;
16125  while(current_xmachine_firm_holder)
16126  {
16127  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
16128  current_xmachine_firm = current_xmachine_firm_holder->agent;
16129  current_xmachine_firm_next_state = firm_FirmLabourPayWages_state;
16130  /* For backwards compatibility set current_xmachine */
16131  current_xmachine->xmachine_firm = NULL;
16132  current_xmachine->xmachine_household = NULL;
16133  current_xmachine->xmachine_equityfund = NULL;
16134  current_xmachine->xmachine_bank = NULL;
16135  current_xmachine->xmachine_government = NULL;
16136  current_xmachine->xmachine_centralbank = NULL;
16137  current_xmachine->xmachine_jpoffice = NULL;
16138  current_xmachine->xmachine_mall = NULL;
16139  current_xmachine->xmachine_reagency = NULL;
16140  current_xmachine->xmachine_firm = current_xmachine_firm;
16141 
16142 
16143 
16144 
16145 
16146 
16147 
16148 
16149  rc = MB_Iterator_CreateFiltered(b_job_match_stage2, &i_job_match_stage2, &FLAME_filter_firm_firm_labour_job_offer_stage2_FirmLabourStage2End_FirmLabourPayWages_job_match_stage2, current_xmachine_firm);
16150 
16151 
16152 
16153  #ifdef ERRCHECK
16154  if (rc != MB_SUCCESS)
16155  {
16156  fprintf(stderr, "ERROR: Could not create Iterator for 'job_match_stage2'\n");
16157  switch(rc) {
16158  case MB_ERR_INVALID:
16159  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
16160  break;
16161  case MB_ERR_LOCKED:
16162  fprintf(stderr, "\t reason: 'job_match_stage2' board is locked\n");
16163  break;
16164  case MB_ERR_MEMALLOC:
16165  fprintf(stderr, "\t reason: out of memory\n");
16166  break;
16167  case MB_ERR_INTERNAL:
16168  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16169  break;
16170  default:
16171 
16172  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
16173 
16174 
16175  break;
16176  }
16177 
16178 
16179  exit(rc);
16180  }
16181  #endif
16182 
16183 
16184 
16185  i = firm_labour_job_offer_stage2();
16186 
16187 
16188  rc = MB_Iterator_Delete(&i_job_match_stage2);
16189  #ifdef ERRCHECK
16190  if (rc != MB_SUCCESS)
16191  {
16192  fprintf(stderr, "ERROR: Could not delete 'job_match_stage2' iterator\n");
16193  switch(rc) {
16194  case MB_ERR_INVALID:
16195  fprintf(stderr, "\t reason: 'job_match_stage2' iterator is invalid\n");
16196  break;
16197  case MB_ERR_INTERNAL:
16198  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16199  break;
16200  default:
16201  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
16202  break;
16203  }
16204 
16205 
16206  exit(rc);
16207  }
16208  #endif
16209 
16210 
16211  if(i == 1)
16212  {
16213  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage2End_state);
16214  }
16215  else
16216  {
16217  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourStage2End_state, firm_FirmLabourPayWages_state);
16218  }
16219 
16220 
16221  current_xmachine_firm = NULL;
16222 
16223  current_xmachine_firm_holder = temp_xmachine_firm_holder;
16224  }
16225  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_job_offer_stage2\n");
16226 
16227 
16228  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_labour_employment\n");
16229  current_xmachine_household_holder = household_HHLabourStage1Placement_state->agents;
16230  while(current_xmachine_household_holder)
16231  {
16232  temp_xmachine_household_holder = current_xmachine_household_holder->next;
16233  current_xmachine_household = current_xmachine_household_holder->agent;
16234  current_xmachine_household_next_state = household_HHLabourEmploymentStatus_state;
16235  /* For backwards compatibility set current_xmachine */
16236  current_xmachine->xmachine_firm = NULL;
16237  current_xmachine->xmachine_household = NULL;
16238  current_xmachine->xmachine_equityfund = NULL;
16239  current_xmachine->xmachine_bank = NULL;
16240  current_xmachine->xmachine_government = NULL;
16241  current_xmachine->xmachine_centralbank = NULL;
16242  current_xmachine->xmachine_jpoffice = NULL;
16243  current_xmachine->xmachine_mall = NULL;
16244  current_xmachine->xmachine_reagency = NULL;
16245  current_xmachine->xmachine_household = current_xmachine_household;
16246 
16247 
16248 
16249 
16250 
16251 
16252 
16253 
16254  rc = MB_Iterator_CreateFiltered(b_job_match_stage2, &i_job_match_stage2, &FLAME_filter_household_household_labour_employment_HHLabourStage1Placement_HHLabourEmploymentStatus_job_match_stage2, current_xmachine_household);
16255 
16256 
16257 
16258  #ifdef ERRCHECK
16259  if (rc != MB_SUCCESS)
16260  {
16261  fprintf(stderr, "ERROR: Could not create Iterator for 'job_match_stage2'\n");
16262  switch(rc) {
16263  case MB_ERR_INVALID:
16264  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
16265  break;
16266  case MB_ERR_LOCKED:
16267  fprintf(stderr, "\t reason: 'job_match_stage2' board is locked\n");
16268  break;
16269  case MB_ERR_MEMALLOC:
16270  fprintf(stderr, "\t reason: out of memory\n");
16271  break;
16272  case MB_ERR_INTERNAL:
16273  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16274  break;
16275  default:
16276 
16277  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
16278 
16279 
16280  break;
16281  }
16282 
16283 
16284  exit(rc);
16285  }
16286  #endif
16287 
16288 
16289 
16290  i = household_labour_employment();
16291 
16292 
16293  rc = MB_Iterator_Delete(&i_job_match_stage2);
16294  #ifdef ERRCHECK
16295  if (rc != MB_SUCCESS)
16296  {
16297  fprintf(stderr, "ERROR: Could not delete 'job_match_stage2' iterator\n");
16298  switch(rc) {
16299  case MB_ERR_INVALID:
16300  fprintf(stderr, "\t reason: 'job_match_stage2' iterator is invalid\n");
16301  break;
16302  case MB_ERR_INTERNAL:
16303  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16304  break;
16305  default:
16306  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
16307  break;
16308  }
16309 
16310 
16311  exit(rc);
16312  }
16313  #endif
16314 
16315 
16316  if(i == 1)
16317  {
16318  free_household_agent(current_xmachine_household_holder, household_HHLabourStage1Placement_state);
16319  }
16320  else
16321  {
16322  transition_household_agent(current_xmachine_household_holder, household_HHLabourStage1Placement_state, household_HHLabourEmploymentStatus_state);
16323  }
16324 
16325 
16326  current_xmachine_household = NULL;
16327 
16328  current_xmachine_household_holder = temp_xmachine_household_holder;
16329  }
16330  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_labour_employment\n");
16331 
16332 
16333 /* End of layer number 35 */
16334 
16335 /* Clear message boards that have finished being used
16336  * and sync complete if doing late sync complete */
16337 
16338 if(FLAME_job_match_stage2_message_board_read == 0)
16339 {
16340  /*printf("%d> job_match_stage2 message board sync complete late as no agents reading any messages of this type\n", node_number);*/
16341 
16342  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_job_match_stage2)\n");
16343  rc = MB_SyncComplete(b_job_match_stage2);
16344  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_job_match_stage2)\n");
16345  #ifdef ERRCHECK
16346  if (rc != MB_SUCCESS)
16347  {
16348  fprintf(stderr, "ERROR: Could not complete sync of 'job_match_stage2' board\n");
16349  switch(rc) {
16350  case MB_ERR_INVALID:
16351  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
16352  break;
16353  case MB_ERR_MEMALLOC:
16354  fprintf(stderr, "\t reason: out of memory\n");
16355  break;
16356  case MB_ERR_INTERNAL:
16357  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16358  break;
16359  default:
16360  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
16361  break;
16362  }
16363 
16364 
16365  exit(rc);
16366  }
16367  #endif
16368 }
16369 
16370  /* Delete any search trees */
16371 
16372  rc = MB_Clear(b_job_match_stage2);
16373  #ifdef ERRCHECK
16374  if (rc != MB_SUCCESS)
16375  {
16376  fprintf(stderr, "ERROR: Could not clear 'job_match_stage2' board\n");
16377  switch(rc) {
16378  case MB_ERR_INVALID:
16379  fprintf(stderr, "\t reason: 'job_match_stage2' board is invalid\n");
16380  break;
16381  case MB_ERR_LOCKED:
16382  fprintf(stderr, "\t reason: 'job_match_stage2' board is locked\n");
16383  break;
16384  case MB_ERR_INTERNAL:
16385  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16386  break;
16387  default:
16388  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
16389  break;
16390 
16391  }
16392 
16393 
16394  exit(rc);
16395  }
16396  #endif
16397 
16398  /* DEBUG: States with branching functions */
16399  current_xmachine_firm_holder = firm_FirmLabourPayWages_state->agents;
16400  while(current_xmachine_firm_holder)
16401  {
16402  FLAME_debug_count = 0;
16403  /* Function: firm_labour_pay_wages */
16404  if(FLAME_condition_firm_firm_labour_pay_wages_FirmLabourPayWages_FirmLabourWageAdjustment(current_xmachine_firm_holder->agent)==1)
16405  { FLAME_debug_count++; }
16406  /* Function: idle */
16407  if(FLAME_condition_firm_idle_FirmLabourPayWages_FirmConsumptionStart(current_xmachine_firm_holder->agent)==1)
16408  { FLAME_debug_count++; }
16409  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
16410  if(FLAME_debug_count != 1)
16411  {
16412  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmLabourPayWages'\n");
16413  if(FLAME_debug_count > 1)
16414  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
16415  if(FLAME_debug_count == 0)
16416  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
16417  }
16418 
16419  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
16420  }
16421 
16422  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_labour_report_status\n");
16423  current_xmachine_household_holder = household_HHLabourEmploymentStatus_state->agents;
16424  while(current_xmachine_household_holder)
16425  {
16426  temp_xmachine_household_holder = current_xmachine_household_holder->next;
16427  current_xmachine_household = current_xmachine_household_holder->agent;
16428  current_xmachine_household_next_state = household_HHLabourPayroll_state;
16429  /* For backwards compatibility set current_xmachine */
16430  current_xmachine->xmachine_firm = NULL;
16431  current_xmachine->xmachine_household = NULL;
16432  current_xmachine->xmachine_equityfund = NULL;
16433  current_xmachine->xmachine_bank = NULL;
16434  current_xmachine->xmachine_government = NULL;
16435  current_xmachine->xmachine_centralbank = NULL;
16436  current_xmachine->xmachine_jpoffice = NULL;
16437  current_xmachine->xmachine_mall = NULL;
16438  current_xmachine->xmachine_reagency = NULL;
16439  current_xmachine->xmachine_household = current_xmachine_household;
16440 
16441 
16442 
16443 
16444 
16445  i = household_labour_report_status();
16446 
16447 
16448 
16449  if(i == 1)
16450  {
16451  free_household_agent(current_xmachine_household_holder, household_HHLabourEmploymentStatus_state);
16452  }
16453  else
16454  {
16455  transition_household_agent(current_xmachine_household_holder, household_HHLabourEmploymentStatus_state, household_HHLabourPayroll_state);
16456  }
16457 
16458 
16459  current_xmachine_household = NULL;
16460 
16461  current_xmachine_household_holder = temp_xmachine_household_holder;
16462  }
16463  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_labour_report_status\n");
16464 
16465  if(FLAME_employment_status_message_board_write == 1)
16466  {
16467 
16468  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_employment_status)\n");
16469  rc = MB_SyncStart(b_employment_status);
16470  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_employment_status)\n");
16471  #ifdef ERRCHECK
16472  if (rc != MB_SUCCESS)
16473  {
16474  fprintf(stderr, "ERROR: Could not start sync of 'employment_status' board\n");
16475  switch(rc) {
16476  case MB_ERR_INVALID:
16477  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
16478  break;
16479  case MB_ERR_LOCKED:
16480  fprintf(stderr, "\t reason: 'employment_status' board is locked\n");
16481  break;
16482  case MB_ERR_MEMALLOC:
16483  fprintf(stderr, "\t reason: out of memory\n");
16484  break;
16485  case MB_ERR_INTERNAL:
16486  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16487  break;
16488  default:
16489  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
16490  break;
16491  }
16492 
16493 
16494  exit(rc);
16495  }
16496  #endif
16497  }
16498 
16499 
16500 
16501  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_pay_wages\n");
16502  current_xmachine_firm_holder = firm_FirmLabourPayWages_state->agents;
16503  while(current_xmachine_firm_holder)
16504  {
16505  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
16506  current_xmachine_firm = current_xmachine_firm_holder->agent;
16507  current_xmachine_firm_next_state = firm_FirmLabourWageAdjustment_state;
16508  /* For backwards compatibility set current_xmachine */
16509  current_xmachine->xmachine_firm = NULL;
16510  current_xmachine->xmachine_household = NULL;
16511  current_xmachine->xmachine_equityfund = NULL;
16512  current_xmachine->xmachine_bank = NULL;
16513  current_xmachine->xmachine_government = NULL;
16514  current_xmachine->xmachine_centralbank = NULL;
16515  current_xmachine->xmachine_jpoffice = NULL;
16516  current_xmachine->xmachine_mall = NULL;
16517  current_xmachine->xmachine_reagency = NULL;
16518  current_xmachine->xmachine_firm = current_xmachine_firm;
16519 
16520  if(FLAME_condition_firm_firm_labour_pay_wages_FirmLabourPayWages_FirmLabourWageAdjustment(current_xmachine_firm)==1)
16521  {
16522 
16523 
16524 
16525  i = firm_labour_pay_wages();
16526 
16527 
16528 
16529  if(i == 1)
16530  {
16531  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourPayWages_state);
16532  }
16533  else
16534  {
16535  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourPayWages_state, firm_FirmLabourWageAdjustment_state);
16536  }
16537  }
16538 
16539  current_xmachine_firm = NULL;
16540 
16541  current_xmachine_firm_holder = temp_xmachine_firm_holder;
16542  }
16543  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_pay_wages\n");
16544 
16545  if(FLAME_labour_tax_message_board_write == 1)
16546  {
16547 
16548  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_labour_tax)\n");
16549  rc = MB_SyncStart(b_labour_tax);
16550  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_labour_tax)\n");
16551  #ifdef ERRCHECK
16552  if (rc != MB_SUCCESS)
16553  {
16554  fprintf(stderr, "ERROR: Could not start sync of 'labour_tax' board\n");
16555  switch(rc) {
16556  case MB_ERR_INVALID:
16557  fprintf(stderr, "\t reason: 'labour_tax' board is invalid\n");
16558  break;
16559  case MB_ERR_LOCKED:
16560  fprintf(stderr, "\t reason: 'labour_tax' board is locked\n");
16561  break;
16562  case MB_ERR_MEMALLOC:
16563  fprintf(stderr, "\t reason: out of memory\n");
16564  break;
16565  case MB_ERR_INTERNAL:
16566  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16567  break;
16568  default:
16569  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
16570  break;
16571  }
16572 
16573 
16574  exit(rc);
16575  }
16576  #endif
16577  }
16578 
16579 
16580 
16581  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
16582  current_xmachine_firm_holder = firm_FirmLabourPayWages_state->agents;
16583  while(current_xmachine_firm_holder)
16584  {
16585  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
16586  current_xmachine_firm = current_xmachine_firm_holder->agent;
16587  current_xmachine_firm_next_state = firm_FirmConsumptionStart_state;
16588  /* For backwards compatibility set current_xmachine */
16589  current_xmachine->xmachine_firm = NULL;
16590  current_xmachine->xmachine_household = NULL;
16591  current_xmachine->xmachine_equityfund = NULL;
16592  current_xmachine->xmachine_bank = NULL;
16593  current_xmachine->xmachine_government = NULL;
16594  current_xmachine->xmachine_centralbank = NULL;
16595  current_xmachine->xmachine_jpoffice = NULL;
16596  current_xmachine->xmachine_mall = NULL;
16597  current_xmachine->xmachine_reagency = NULL;
16598  current_xmachine->xmachine_firm = current_xmachine_firm;
16599 
16600  if(FLAME_condition_firm_idle_FirmLabourPayWages_FirmConsumptionStart(current_xmachine_firm)==1)
16601  {
16602 
16603 
16604 
16605  i = idle();
16606 
16607 
16608 
16609  if(i == 1)
16610  {
16611  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourPayWages_state);
16612  }
16613  else
16614  {
16615  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourPayWages_state, firm_FirmConsumptionStart_state);
16616  }
16617  }
16618 
16619  current_xmachine_firm = NULL;
16620 
16621  current_xmachine_firm_holder = temp_xmachine_firm_holder;
16622  }
16623  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
16624 
16625 
16626 /* End of layer number 36 */
16627 
16628 /* Clear message boards that have finished being used
16629  * and sync complete if doing late sync complete */
16630 
16631  /* DEBUG: States with branching functions */
16632  current_xmachine_household_holder = household_HHLabourPayroll_state->agents;
16633  while(current_xmachine_household_holder)
16634  {
16635  FLAME_debug_count = 0;
16636  /* Function: household_labour_recieve_wage */
16637  if(FLAME_condition_household_household_labour_recieve_wage_HHLabourPayroll_HHConsumptionStart(current_xmachine_household_holder->agent)==1)
16638  { FLAME_debug_count++; }
16639  /* Function: idle */
16640  if(FLAME_condition_household_idle_HHLabourPayroll_HHConsumptionStart(current_xmachine_household_holder->agent)==1)
16641  { FLAME_debug_count++; }
16642  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
16643  if(FLAME_debug_count != 1)
16644  {
16645  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHLabourPayroll'\n");
16646  if(FLAME_debug_count > 1)
16647  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
16648  if(FLAME_debug_count == 0)
16649  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
16650  }
16651 
16652  current_xmachine_household_holder = current_xmachine_household_holder->next;
16653  }
16654 
16655  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_labour_recieve_wage\n");
16656  current_xmachine_household_holder = household_HHLabourPayroll_state->agents;
16657  while(current_xmachine_household_holder)
16658  {
16659  temp_xmachine_household_holder = current_xmachine_household_holder->next;
16660  current_xmachine_household = current_xmachine_household_holder->agent;
16661  current_xmachine_household_next_state = household_HHConsumptionStart_state;
16662  /* For backwards compatibility set current_xmachine */
16663  current_xmachine->xmachine_firm = NULL;
16664  current_xmachine->xmachine_household = NULL;
16665  current_xmachine->xmachine_equityfund = NULL;
16666  current_xmachine->xmachine_bank = NULL;
16667  current_xmachine->xmachine_government = NULL;
16668  current_xmachine->xmachine_centralbank = NULL;
16669  current_xmachine->xmachine_jpoffice = NULL;
16670  current_xmachine->xmachine_mall = NULL;
16671  current_xmachine->xmachine_reagency = NULL;
16672  current_xmachine->xmachine_household = current_xmachine_household;
16673 
16674  if(FLAME_condition_household_household_labour_recieve_wage_HHLabourPayroll_HHConsumptionStart(current_xmachine_household)==1)
16675  {
16676 
16677 
16678 
16679  i = household_labour_recieve_wage();
16680 
16681 
16682 
16683  if(i == 1)
16684  {
16685  free_household_agent(current_xmachine_household_holder, household_HHLabourPayroll_state);
16686  }
16687  else
16688  {
16689  transition_household_agent(current_xmachine_household_holder, household_HHLabourPayroll_state, household_HHConsumptionStart_state);
16690  }
16691  }
16692 
16693  current_xmachine_household = NULL;
16694 
16695  current_xmachine_household_holder = temp_xmachine_household_holder;
16696  }
16697  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_labour_recieve_wage\n");
16698 
16699 
16700  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
16701  current_xmachine_household_holder = household_HHLabourPayroll_state->agents;
16702  while(current_xmachine_household_holder)
16703  {
16704  temp_xmachine_household_holder = current_xmachine_household_holder->next;
16705  current_xmachine_household = current_xmachine_household_holder->agent;
16706  current_xmachine_household_next_state = household_HHConsumptionStart_state;
16707  /* For backwards compatibility set current_xmachine */
16708  current_xmachine->xmachine_firm = NULL;
16709  current_xmachine->xmachine_household = NULL;
16710  current_xmachine->xmachine_equityfund = NULL;
16711  current_xmachine->xmachine_bank = NULL;
16712  current_xmachine->xmachine_government = NULL;
16713  current_xmachine->xmachine_centralbank = NULL;
16714  current_xmachine->xmachine_jpoffice = NULL;
16715  current_xmachine->xmachine_mall = NULL;
16716  current_xmachine->xmachine_reagency = NULL;
16717  current_xmachine->xmachine_household = current_xmachine_household;
16718 
16719  if(FLAME_condition_household_idle_HHLabourPayroll_HHConsumptionStart(current_xmachine_household)==1)
16720  {
16721 
16722 
16723 
16724  i = idle();
16725 
16726 
16727 
16728  if(i == 1)
16729  {
16730  free_household_agent(current_xmachine_household_holder, household_HHLabourPayroll_state);
16731  }
16732  else
16733  {
16734  transition_household_agent(current_xmachine_household_holder, household_HHLabourPayroll_state, household_HHConsumptionStart_state);
16735  }
16736  }
16737 
16738  current_xmachine_household = NULL;
16739 
16740  current_xmachine_household_holder = temp_xmachine_household_holder;
16741  }
16742  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
16743 
16744 
16745  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_labour_trace_wages\n");
16746  current_xmachine_firm_holder = firm_FirmLabourWageAdjustment_state->agents;
16747  while(current_xmachine_firm_holder)
16748  {
16749  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
16750  current_xmachine_firm = current_xmachine_firm_holder->agent;
16751  current_xmachine_firm_next_state = firm_FirmConsumptionStart_state;
16752  /* For backwards compatibility set current_xmachine */
16753  current_xmachine->xmachine_firm = NULL;
16754  current_xmachine->xmachine_household = NULL;
16755  current_xmachine->xmachine_equityfund = NULL;
16756  current_xmachine->xmachine_bank = NULL;
16757  current_xmachine->xmachine_government = NULL;
16758  current_xmachine->xmachine_centralbank = NULL;
16759  current_xmachine->xmachine_jpoffice = NULL;
16760  current_xmachine->xmachine_mall = NULL;
16761  current_xmachine->xmachine_reagency = NULL;
16762  current_xmachine->xmachine_firm = current_xmachine_firm;
16763 
16764 
16765 
16766 
16767 
16768  i = firm_labour_trace_wages();
16769 
16770 
16771 
16772  if(i == 1)
16773  {
16774  free_firm_agent(current_xmachine_firm_holder, firm_FirmLabourWageAdjustment_state);
16775  }
16776  else
16777  {
16778  transition_firm_agent(current_xmachine_firm_holder, firm_FirmLabourWageAdjustment_state, firm_FirmConsumptionStart_state);
16779  }
16780 
16781 
16782  current_xmachine_firm = NULL;
16783 
16784  current_xmachine_firm_holder = temp_xmachine_firm_holder;
16785  }
16786  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_labour_trace_wages\n");
16787 
16788 
16789  /* If mb is not read then leave sync complete until last possible moment */
16790  if(FLAME_employment_status_message_board_read == 1)
16791  {
16792  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_employment_status)\n");
16793  rc = MB_SyncComplete(b_employment_status);
16794  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_employment_status)\n");
16795  #ifdef ERRCHECK
16796  if (rc != MB_SUCCESS)
16797  {
16798  fprintf(stderr, "ERROR: Could not complete sync of 'employment_status' board\n");
16799  switch(rc) {
16800  case MB_ERR_INVALID:
16801  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
16802  break;
16803  case MB_ERR_MEMALLOC:
16804  fprintf(stderr, "\t reason: out of memory\n");
16805  break;
16806  case MB_ERR_INTERNAL:
16807  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16808  break;
16809  default:
16810  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
16811  break;
16812  }
16813 
16814 
16815  exit(rc);
16816  }
16817  #endif
16818 
16819 
16820 
16821  }
16822 
16823  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start equityfund_audit_dividends\n");
16824  current_xmachine_equityfund_holder = equityfund_EFLabourMarket_state->agents;
16825  while(current_xmachine_equityfund_holder)
16826  {
16827  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
16828  current_xmachine_equityfund = current_xmachine_equityfund_holder->agent;
16829  current_xmachine_equityfund_next_state = equityfund_end_state;
16830  /* For backwards compatibility set current_xmachine */
16831  current_xmachine->xmachine_firm = NULL;
16832  current_xmachine->xmachine_household = NULL;
16833  current_xmachine->xmachine_equityfund = NULL;
16834  current_xmachine->xmachine_bank = NULL;
16835  current_xmachine->xmachine_government = NULL;
16836  current_xmachine->xmachine_centralbank = NULL;
16837  current_xmachine->xmachine_jpoffice = NULL;
16838  current_xmachine->xmachine_mall = NULL;
16839  current_xmachine->xmachine_reagency = NULL;
16840  current_xmachine->xmachine_equityfund = current_xmachine_equityfund;
16841 
16842  if(FLAME_condition_equityfund_equityfund_audit_dividends_EFLabourMarket_end(current_xmachine_equityfund)==1)
16843  {
16844 
16845 
16846 
16847 
16848  rc = MB_Iterator_Create(b_employment_status, &i_employment_status);
16849 
16850 
16851  #ifdef ERRCHECK
16852  if (rc != MB_SUCCESS)
16853  {
16854  fprintf(stderr, "ERROR: Could not create Iterator for 'employment_status'\n");
16855  switch(rc) {
16856  case MB_ERR_INVALID:
16857  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
16858  break;
16859  case MB_ERR_LOCKED:
16860  fprintf(stderr, "\t reason: 'employment_status' board is locked\n");
16861  break;
16862  case MB_ERR_MEMALLOC:
16863  fprintf(stderr, "\t reason: out of memory\n");
16864  break;
16865  case MB_ERR_INTERNAL:
16866  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16867  break;
16868  default:
16869 
16870 
16871  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
16872 
16873  break;
16874  }
16875 
16876 
16877  exit(rc);
16878  }
16879  #endif
16880 
16881 
16882 
16883  i = equityfund_audit_dividends();
16884 
16885 
16886  rc = MB_Iterator_Delete(&i_employment_status);
16887  #ifdef ERRCHECK
16888  if (rc != MB_SUCCESS)
16889  {
16890  fprintf(stderr, "ERROR: Could not delete 'employment_status' iterator\n");
16891  switch(rc) {
16892  case MB_ERR_INVALID:
16893  fprintf(stderr, "\t reason: 'employment_status' iterator is invalid\n");
16894  break;
16895  case MB_ERR_INTERNAL:
16896  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16897  break;
16898  default:
16899  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
16900  break;
16901  }
16902 
16903 
16904  exit(rc);
16905  }
16906  #endif
16907 
16908 
16909  if(i == 1)
16910  {
16911  free_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFLabourMarket_state);
16912  }
16913  else
16914  {
16915  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_EFLabourMarket_state, equityfund_end_state);
16916  }
16917  }
16918 
16919  current_xmachine_equityfund = NULL;
16920 
16921  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
16922  }
16923  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish equityfund_audit_dividends\n");
16924 
16925 
16926  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_trace_unemployment_status\n");
16927  current_xmachine_centralbank_holder = centralbank_CentralBankLabour_state->agents;
16928  while(current_xmachine_centralbank_holder)
16929  {
16930  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
16931  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
16932  current_xmachine_centralbank_next_state = centralbank_CentralBankConsumption_state;
16933  /* For backwards compatibility set current_xmachine */
16934  current_xmachine->xmachine_firm = NULL;
16935  current_xmachine->xmachine_household = NULL;
16936  current_xmachine->xmachine_equityfund = NULL;
16937  current_xmachine->xmachine_bank = NULL;
16938  current_xmachine->xmachine_government = NULL;
16939  current_xmachine->xmachine_centralbank = NULL;
16940  current_xmachine->xmachine_jpoffice = NULL;
16941  current_xmachine->xmachine_mall = NULL;
16942  current_xmachine->xmachine_reagency = NULL;
16943  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
16944 
16945  if(FLAME_condition_centralbank_centralbank_trace_unemployment_status_CentralBankLabour_CentralBankConsumption(current_xmachine_centralbank)==1)
16946  {
16947 
16948 
16949 
16950 
16951  rc = MB_Iterator_Create(b_employment_status, &i_employment_status);
16952 
16953 
16954  #ifdef ERRCHECK
16955  if (rc != MB_SUCCESS)
16956  {
16957  fprintf(stderr, "ERROR: Could not create Iterator for 'employment_status'\n");
16958  switch(rc) {
16959  case MB_ERR_INVALID:
16960  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
16961  break;
16962  case MB_ERR_LOCKED:
16963  fprintf(stderr, "\t reason: 'employment_status' board is locked\n");
16964  break;
16965  case MB_ERR_MEMALLOC:
16966  fprintf(stderr, "\t reason: out of memory\n");
16967  break;
16968  case MB_ERR_INTERNAL:
16969  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
16970  break;
16971  default:
16972 
16973 
16974  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
16975 
16976  break;
16977  }
16978 
16979 
16980  exit(rc);
16981  }
16982  #endif
16983 
16984 
16985 
16986  i = centralbank_trace_unemployment_status();
16987 
16988 
16989  rc = MB_Iterator_Delete(&i_employment_status);
16990  #ifdef ERRCHECK
16991  if (rc != MB_SUCCESS)
16992  {
16993  fprintf(stderr, "ERROR: Could not delete 'employment_status' iterator\n");
16994  switch(rc) {
16995  case MB_ERR_INVALID:
16996  fprintf(stderr, "\t reason: 'employment_status' iterator is invalid\n");
16997  break;
16998  case MB_ERR_INTERNAL:
16999  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17000  break;
17001  default:
17002  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
17003  break;
17004  }
17005 
17006 
17007  exit(rc);
17008  }
17009  #endif
17010 
17011 
17012  if(i == 1)
17013  {
17014  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankLabour_state);
17015  }
17016  else
17017  {
17018  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankLabour_state, centralbank_CentralBankConsumption_state);
17019  }
17020  }
17021 
17022  current_xmachine_centralbank = NULL;
17023 
17024  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
17025  }
17026  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_trace_unemployment_status\n");
17027 
17028 
17029  /* If mb is not read then leave sync complete until last possible moment */
17030  if(FLAME_labour_tax_message_board_read == 1)
17031  {
17032  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_labour_tax)\n");
17033  rc = MB_SyncComplete(b_labour_tax);
17034  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_labour_tax)\n");
17035  #ifdef ERRCHECK
17036  if (rc != MB_SUCCESS)
17037  {
17038  fprintf(stderr, "ERROR: Could not complete sync of 'labour_tax' board\n");
17039  switch(rc) {
17040  case MB_ERR_INVALID:
17041  fprintf(stderr, "\t reason: 'labour_tax' board is invalid\n");
17042  break;
17043  case MB_ERR_MEMALLOC:
17044  fprintf(stderr, "\t reason: out of memory\n");
17045  break;
17046  case MB_ERR_INTERNAL:
17047  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17048  break;
17049  default:
17050  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
17051  break;
17052  }
17053 
17054 
17055  exit(rc);
17056  }
17057  #endif
17058 
17059 
17060 
17061  }
17062 
17063  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_collect_labour_tax\n");
17064  current_xmachine_government_holder = government_GovernmentLabourTax_state->agents;
17065  while(current_xmachine_government_holder)
17066  {
17067  temp_xmachine_government_holder = current_xmachine_government_holder->next;
17068  current_xmachine_government = current_xmachine_government_holder->agent;
17069  current_xmachine_government_next_state = government_GovernmentLabourStatus_state;
17070  /* For backwards compatibility set current_xmachine */
17071  current_xmachine->xmachine_firm = NULL;
17072  current_xmachine->xmachine_household = NULL;
17073  current_xmachine->xmachine_equityfund = NULL;
17074  current_xmachine->xmachine_bank = NULL;
17075  current_xmachine->xmachine_government = NULL;
17076  current_xmachine->xmachine_centralbank = NULL;
17077  current_xmachine->xmachine_jpoffice = NULL;
17078  current_xmachine->xmachine_mall = NULL;
17079  current_xmachine->xmachine_reagency = NULL;
17080  current_xmachine->xmachine_government = current_xmachine_government;
17081 
17082 
17083 
17084 
17085 
17086 
17087  rc = MB_Iterator_Create(b_labour_tax, &i_labour_tax);
17088 
17089 
17090  #ifdef ERRCHECK
17091  if (rc != MB_SUCCESS)
17092  {
17093  fprintf(stderr, "ERROR: Could not create Iterator for 'labour_tax'\n");
17094  switch(rc) {
17095  case MB_ERR_INVALID:
17096  fprintf(stderr, "\t reason: 'labour_tax' board is invalid\n");
17097  break;
17098  case MB_ERR_LOCKED:
17099  fprintf(stderr, "\t reason: 'labour_tax' board is locked\n");
17100  break;
17101  case MB_ERR_MEMALLOC:
17102  fprintf(stderr, "\t reason: out of memory\n");
17103  break;
17104  case MB_ERR_INTERNAL:
17105  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17106  break;
17107  default:
17108 
17109 
17110  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
17111 
17112  break;
17113  }
17114 
17115 
17116  exit(rc);
17117  }
17118  #endif
17119 
17120 
17121 
17122  i = government_collect_labour_tax();
17123 
17124 
17125  rc = MB_Iterator_Delete(&i_labour_tax);
17126  #ifdef ERRCHECK
17127  if (rc != MB_SUCCESS)
17128  {
17129  fprintf(stderr, "ERROR: Could not delete 'labour_tax' iterator\n");
17130  switch(rc) {
17131  case MB_ERR_INVALID:
17132  fprintf(stderr, "\t reason: 'labour_tax' iterator is invalid\n");
17133  break;
17134  case MB_ERR_INTERNAL:
17135  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17136  break;
17137  default:
17138  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
17139  break;
17140  }
17141 
17142 
17143  exit(rc);
17144  }
17145  #endif
17146 
17147 
17148  if(i == 1)
17149  {
17150  free_government_agent(current_xmachine_government_holder, government_GovernmentLabourTax_state);
17151  }
17152  else
17153  {
17154  transition_government_agent(current_xmachine_government_holder, government_GovernmentLabourTax_state, government_GovernmentLabourStatus_state);
17155  }
17156 
17157 
17158  current_xmachine_government = NULL;
17159 
17160  current_xmachine_government_holder = temp_xmachine_government_holder;
17161  }
17162  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_collect_labour_tax\n");
17163 
17164 
17165 /* End of layer number 37 */
17166 
17167 /* Clear message boards that have finished being used
17168  * and sync complete if doing late sync complete */
17169 
17170 if(FLAME_labour_tax_message_board_read == 0)
17171 {
17172  /*printf("%d> labour_tax message board sync complete late as no agents reading any messages of this type\n", node_number);*/
17173 
17174  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_labour_tax)\n");
17175  rc = MB_SyncComplete(b_labour_tax);
17176  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_labour_tax)\n");
17177  #ifdef ERRCHECK
17178  if (rc != MB_SUCCESS)
17179  {
17180  fprintf(stderr, "ERROR: Could not complete sync of 'labour_tax' board\n");
17181  switch(rc) {
17182  case MB_ERR_INVALID:
17183  fprintf(stderr, "\t reason: 'labour_tax' board is invalid\n");
17184  break;
17185  case MB_ERR_MEMALLOC:
17186  fprintf(stderr, "\t reason: out of memory\n");
17187  break;
17188  case MB_ERR_INTERNAL:
17189  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17190  break;
17191  default:
17192  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
17193  break;
17194  }
17195 
17196 
17197  exit(rc);
17198  }
17199  #endif
17200 }
17201 
17202  /* Delete any search trees */
17203 
17204  rc = MB_Clear(b_labour_tax);
17205  #ifdef ERRCHECK
17206  if (rc != MB_SUCCESS)
17207  {
17208  fprintf(stderr, "ERROR: Could not clear 'labour_tax' board\n");
17209  switch(rc) {
17210  case MB_ERR_INVALID:
17211  fprintf(stderr, "\t reason: 'labour_tax' board is invalid\n");
17212  break;
17213  case MB_ERR_LOCKED:
17214  fprintf(stderr, "\t reason: 'labour_tax' board is locked\n");
17215  break;
17216  case MB_ERR_INTERNAL:
17217  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17218  break;
17219  default:
17220  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
17221  break;
17222 
17223  }
17224 
17225 
17226  exit(rc);
17227  }
17228  #endif
17229 
17230  /* DEBUG: States with branching functions */
17231  current_xmachine_firm_holder = firm_FirmConsumptionStart_state->agents;
17232  while(current_xmachine_firm_holder)
17233  {
17234  FLAME_debug_count = 0;
17235  /* Function: firm_consumption_supply */
17236  if(FLAME_condition_firm_firm_consumption_supply_FirmConsumptionStart_FirmRecieveSales(current_xmachine_firm_holder->agent)==1)
17237  { FLAME_debug_count++; }
17238  /* Function: idle */
17239  if(FLAME_condition_firm_idle_FirmConsumptionStart_FirmHousingStart(current_xmachine_firm_holder->agent)==1)
17240  { FLAME_debug_count++; }
17241  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
17242  if(FLAME_debug_count != 1)
17243  {
17244  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmConsumptionStart'\n");
17245  if(FLAME_debug_count > 1)
17246  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
17247  if(FLAME_debug_count == 0)
17248  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
17249  }
17250 
17251  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
17252  }
17253  /* DEBUG: States with branching functions */
17254  current_xmachine_household_holder = household_HHConsumptionStart_state->agents;
17255  while(current_xmachine_household_holder)
17256  {
17257  FLAME_debug_count = 0;
17258  /* Function: household_consumption_compute_budget */
17259  if(FLAME_condition_household_household_consumption_compute_budget_HHConsumptionStart_HHConsumptionWeekly(current_xmachine_household_holder->agent)==1)
17260  { FLAME_debug_count++; }
17261  /* Function: idle */
17262  if(FLAME_condition_household_idle_HHConsumptionStart_HHConsumptionWeekly(current_xmachine_household_holder->agent)==1)
17263  { FLAME_debug_count++; }
17264  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
17265  if(FLAME_debug_count != 1)
17266  {
17267  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHConsumptionStart'\n");
17268  if(FLAME_debug_count > 1)
17269  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
17270  if(FLAME_debug_count == 0)
17271  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
17272  }
17273 
17274  current_xmachine_household_holder = current_xmachine_household_holder->next;
17275  }
17276  /* DEBUG: States with branching functions */
17277  current_xmachine_centralbank_holder = centralbank_CentralBankConsumption_state->agents;
17278  while(current_xmachine_centralbank_holder)
17279  {
17280  FLAME_debug_count = 0;
17281  /* Function: centralbank_trace_goods_prices */
17282  if(FLAME_condition_centralbank_centralbank_trace_goods_prices_CentralBankConsumption_CentralBankHousing(current_xmachine_centralbank_holder->agent)==1)
17283  { FLAME_debug_count++; }
17284  /* Function: idle */
17285  if(FLAME_condition_centralbank_idle_CentralBankConsumption_CentralBankHousing(current_xmachine_centralbank_holder->agent)==1)
17286  { FLAME_debug_count++; }
17287  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
17288  if(FLAME_debug_count != 1)
17289  {
17290  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'centralbank' leaving state 'CentralBankConsumption'\n");
17291  if(FLAME_debug_count > 1)
17292  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
17293  if(FLAME_debug_count == 0)
17294  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
17295  }
17296 
17297  current_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
17298  }
17299 
17300  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_consumption_supply\n");
17301  current_xmachine_firm_holder = firm_FirmConsumptionStart_state->agents;
17302  while(current_xmachine_firm_holder)
17303  {
17304  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
17305  current_xmachine_firm = current_xmachine_firm_holder->agent;
17306  current_xmachine_firm_next_state = firm_FirmRecieveSales_state;
17307  /* For backwards compatibility set current_xmachine */
17308  current_xmachine->xmachine_firm = NULL;
17309  current_xmachine->xmachine_household = NULL;
17310  current_xmachine->xmachine_equityfund = NULL;
17311  current_xmachine->xmachine_bank = NULL;
17312  current_xmachine->xmachine_government = NULL;
17313  current_xmachine->xmachine_centralbank = NULL;
17314  current_xmachine->xmachine_jpoffice = NULL;
17315  current_xmachine->xmachine_mall = NULL;
17316  current_xmachine->xmachine_reagency = NULL;
17317  current_xmachine->xmachine_firm = current_xmachine_firm;
17318 
17319  if(FLAME_condition_firm_firm_consumption_supply_FirmConsumptionStart_FirmRecieveSales(current_xmachine_firm)==1)
17320  {
17321 
17322 
17323 
17324  i = firm_consumption_supply();
17325 
17326 
17327 
17328  if(i == 1)
17329  {
17330  free_firm_agent(current_xmachine_firm_holder, firm_FirmConsumptionStart_state);
17331  }
17332  else
17333  {
17334  transition_firm_agent(current_xmachine_firm_holder, firm_FirmConsumptionStart_state, firm_FirmRecieveSales_state);
17335  }
17336  }
17337 
17338  current_xmachine_firm = NULL;
17339 
17340  current_xmachine_firm_holder = temp_xmachine_firm_holder;
17341  }
17342  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_consumption_supply\n");
17343 
17344  if(FLAME_sell_message_board_write == 1)
17345  {
17346 
17347  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sell)\n");
17348  rc = MB_SyncStart(b_sell);
17349  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sell)\n");
17350  #ifdef ERRCHECK
17351  if (rc != MB_SUCCESS)
17352  {
17353  fprintf(stderr, "ERROR: Could not start sync of 'sell' board\n");
17354  switch(rc) {
17355  case MB_ERR_INVALID:
17356  fprintf(stderr, "\t reason: 'sell' board is invalid\n");
17357  break;
17358  case MB_ERR_LOCKED:
17359  fprintf(stderr, "\t reason: 'sell' board is locked\n");
17360  break;
17361  case MB_ERR_MEMALLOC:
17362  fprintf(stderr, "\t reason: out of memory\n");
17363  break;
17364  case MB_ERR_INTERNAL:
17365  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17366  break;
17367  default:
17368  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
17369  break;
17370  }
17371 
17372 
17373  exit(rc);
17374  }
17375  #endif
17376  }
17377 
17378 
17379 
17380  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
17381  current_xmachine_centralbank_holder = centralbank_CentralBankConsumption_state->agents;
17382  while(current_xmachine_centralbank_holder)
17383  {
17384  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
17385  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
17386  current_xmachine_centralbank_next_state = centralbank_CentralBankHousing_state;
17387  /* For backwards compatibility set current_xmachine */
17388  current_xmachine->xmachine_firm = NULL;
17389  current_xmachine->xmachine_household = NULL;
17390  current_xmachine->xmachine_equityfund = NULL;
17391  current_xmachine->xmachine_bank = NULL;
17392  current_xmachine->xmachine_government = NULL;
17393  current_xmachine->xmachine_centralbank = NULL;
17394  current_xmachine->xmachine_jpoffice = NULL;
17395  current_xmachine->xmachine_mall = NULL;
17396  current_xmachine->xmachine_reagency = NULL;
17397  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
17398 
17399  if(FLAME_condition_centralbank_idle_CentralBankConsumption_CentralBankHousing(current_xmachine_centralbank)==1)
17400  {
17401 
17402 
17403 
17404  i = idle();
17405 
17406 
17407 
17408  if(i == 1)
17409  {
17410  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankConsumption_state);
17411  }
17412  else
17413  {
17414  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankConsumption_state, centralbank_CentralBankHousing_state);
17415  }
17416  }
17417 
17418  current_xmachine_centralbank = NULL;
17419 
17420  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
17421  }
17422  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
17423 
17424 
17425  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_consumption_compute_budget\n");
17426  current_xmachine_household_holder = household_HHConsumptionStart_state->agents;
17427  while(current_xmachine_household_holder)
17428  {
17429  temp_xmachine_household_holder = current_xmachine_household_holder->next;
17430  current_xmachine_household = current_xmachine_household_holder->agent;
17431  current_xmachine_household_next_state = household_HHConsumptionWeekly_state;
17432  /* For backwards compatibility set current_xmachine */
17433  current_xmachine->xmachine_firm = NULL;
17434  current_xmachine->xmachine_household = NULL;
17435  current_xmachine->xmachine_equityfund = NULL;
17436  current_xmachine->xmachine_bank = NULL;
17437  current_xmachine->xmachine_government = NULL;
17438  current_xmachine->xmachine_centralbank = NULL;
17439  current_xmachine->xmachine_jpoffice = NULL;
17440  current_xmachine->xmachine_mall = NULL;
17441  current_xmachine->xmachine_reagency = NULL;
17442  current_xmachine->xmachine_household = current_xmachine_household;
17443 
17444  if(FLAME_condition_household_household_consumption_compute_budget_HHConsumptionStart_HHConsumptionWeekly(current_xmachine_household)==1)
17445  {
17446 
17447 
17448 
17449  i = household_consumption_compute_budget();
17450 
17451 
17452 
17453  if(i == 1)
17454  {
17455  free_household_agent(current_xmachine_household_holder, household_HHConsumptionStart_state);
17456  }
17457  else
17458  {
17459  transition_household_agent(current_xmachine_household_holder, household_HHConsumptionStart_state, household_HHConsumptionWeekly_state);
17460  }
17461  }
17462 
17463  current_xmachine_household = NULL;
17464 
17465  current_xmachine_household_holder = temp_xmachine_household_holder;
17466  }
17467  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_consumption_compute_budget\n");
17468 
17469 
17470  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
17471  current_xmachine_household_holder = household_HHConsumptionStart_state->agents;
17472  while(current_xmachine_household_holder)
17473  {
17474  temp_xmachine_household_holder = current_xmachine_household_holder->next;
17475  current_xmachine_household = current_xmachine_household_holder->agent;
17476  current_xmachine_household_next_state = household_HHConsumptionWeekly_state;
17477  /* For backwards compatibility set current_xmachine */
17478  current_xmachine->xmachine_firm = NULL;
17479  current_xmachine->xmachine_household = NULL;
17480  current_xmachine->xmachine_equityfund = NULL;
17481  current_xmachine->xmachine_bank = NULL;
17482  current_xmachine->xmachine_government = NULL;
17483  current_xmachine->xmachine_centralbank = NULL;
17484  current_xmachine->xmachine_jpoffice = NULL;
17485  current_xmachine->xmachine_mall = NULL;
17486  current_xmachine->xmachine_reagency = NULL;
17487  current_xmachine->xmachine_household = current_xmachine_household;
17488 
17489  if(FLAME_condition_household_idle_HHConsumptionStart_HHConsumptionWeekly(current_xmachine_household)==1)
17490  {
17491 
17492 
17493 
17494  i = idle();
17495 
17496 
17497 
17498  if(i == 1)
17499  {
17500  free_household_agent(current_xmachine_household_holder, household_HHConsumptionStart_state);
17501  }
17502  else
17503  {
17504  transition_household_agent(current_xmachine_household_holder, household_HHConsumptionStart_state, household_HHConsumptionWeekly_state);
17505  }
17506  }
17507 
17508  current_xmachine_household = NULL;
17509 
17510  current_xmachine_household_holder = temp_xmachine_household_holder;
17511  }
17512  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
17513 
17514 
17515  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
17516  current_xmachine_firm_holder = firm_FirmConsumptionStart_state->agents;
17517  while(current_xmachine_firm_holder)
17518  {
17519  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
17520  current_xmachine_firm = current_xmachine_firm_holder->agent;
17521  current_xmachine_firm_next_state = firm_FirmHousingStart_state;
17522  /* For backwards compatibility set current_xmachine */
17523  current_xmachine->xmachine_firm = NULL;
17524  current_xmachine->xmachine_household = NULL;
17525  current_xmachine->xmachine_equityfund = NULL;
17526  current_xmachine->xmachine_bank = NULL;
17527  current_xmachine->xmachine_government = NULL;
17528  current_xmachine->xmachine_centralbank = NULL;
17529  current_xmachine->xmachine_jpoffice = NULL;
17530  current_xmachine->xmachine_mall = NULL;
17531  current_xmachine->xmachine_reagency = NULL;
17532  current_xmachine->xmachine_firm = current_xmachine_firm;
17533 
17534  if(FLAME_condition_firm_idle_FirmConsumptionStart_FirmHousingStart(current_xmachine_firm)==1)
17535  {
17536 
17537 
17538 
17539  i = idle();
17540 
17541 
17542 
17543  if(i == 1)
17544  {
17545  free_firm_agent(current_xmachine_firm_holder, firm_FirmConsumptionStart_state);
17546  }
17547  else
17548  {
17549  transition_firm_agent(current_xmachine_firm_holder, firm_FirmConsumptionStart_state, firm_FirmHousingStart_state);
17550  }
17551  }
17552 
17553  current_xmachine_firm = NULL;
17554 
17555  current_xmachine_firm_holder = temp_xmachine_firm_holder;
17556  }
17557  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
17558 
17559 
17560  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start government_trace_unemployment_status\n");
17561  current_xmachine_government_holder = government_GovernmentLabourStatus_state->agents;
17562  while(current_xmachine_government_holder)
17563  {
17564  temp_xmachine_government_holder = current_xmachine_government_holder->next;
17565  current_xmachine_government = current_xmachine_government_holder->agent;
17566  current_xmachine_government_next_state = government_end_state;
17567  /* For backwards compatibility set current_xmachine */
17568  current_xmachine->xmachine_firm = NULL;
17569  current_xmachine->xmachine_household = NULL;
17570  current_xmachine->xmachine_equityfund = NULL;
17571  current_xmachine->xmachine_bank = NULL;
17572  current_xmachine->xmachine_government = NULL;
17573  current_xmachine->xmachine_centralbank = NULL;
17574  current_xmachine->xmachine_jpoffice = NULL;
17575  current_xmachine->xmachine_mall = NULL;
17576  current_xmachine->xmachine_reagency = NULL;
17577  current_xmachine->xmachine_government = current_xmachine_government;
17578 
17579 
17580 
17581 
17582 
17583 
17584  rc = MB_Iterator_Create(b_employment_status, &i_employment_status);
17585 
17586 
17587  #ifdef ERRCHECK
17588  if (rc != MB_SUCCESS)
17589  {
17590  fprintf(stderr, "ERROR: Could not create Iterator for 'employment_status'\n");
17591  switch(rc) {
17592  case MB_ERR_INVALID:
17593  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
17594  break;
17595  case MB_ERR_LOCKED:
17596  fprintf(stderr, "\t reason: 'employment_status' board is locked\n");
17597  break;
17598  case MB_ERR_MEMALLOC:
17599  fprintf(stderr, "\t reason: out of memory\n");
17600  break;
17601  case MB_ERR_INTERNAL:
17602  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17603  break;
17604  default:
17605 
17606 
17607  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
17608 
17609  break;
17610  }
17611 
17612 
17613  exit(rc);
17614  }
17615  #endif
17616 
17617 
17618 
17619  i = government_trace_unemployment_status();
17620 
17621 
17622  rc = MB_Iterator_Delete(&i_employment_status);
17623  #ifdef ERRCHECK
17624  if (rc != MB_SUCCESS)
17625  {
17626  fprintf(stderr, "ERROR: Could not delete 'employment_status' iterator\n");
17627  switch(rc) {
17628  case MB_ERR_INVALID:
17629  fprintf(stderr, "\t reason: 'employment_status' iterator is invalid\n");
17630  break;
17631  case MB_ERR_INTERNAL:
17632  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17633  break;
17634  default:
17635  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
17636  break;
17637  }
17638 
17639 
17640  exit(rc);
17641  }
17642  #endif
17643 
17644 
17645  if(i == 1)
17646  {
17647  free_government_agent(current_xmachine_government_holder, government_GovernmentLabourStatus_state);
17648  }
17649  else
17650  {
17651  transition_government_agent(current_xmachine_government_holder, government_GovernmentLabourStatus_state, government_end_state);
17652  }
17653 
17654 
17655  current_xmachine_government = NULL;
17656 
17657  current_xmachine_government_holder = temp_xmachine_government_holder;
17658  }
17659  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish government_trace_unemployment_status\n");
17660 
17661 
17662 /* End of layer number 38 */
17663 
17664 /* Clear message boards that have finished being used
17665  * and sync complete if doing late sync complete */
17666 
17667 if(FLAME_employment_status_message_board_read == 0)
17668 {
17669  /*printf("%d> employment_status message board sync complete late as no agents reading any messages of this type\n", node_number);*/
17670 
17671  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_employment_status)\n");
17672  rc = MB_SyncComplete(b_employment_status);
17673  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_employment_status)\n");
17674  #ifdef ERRCHECK
17675  if (rc != MB_SUCCESS)
17676  {
17677  fprintf(stderr, "ERROR: Could not complete sync of 'employment_status' board\n");
17678  switch(rc) {
17679  case MB_ERR_INVALID:
17680  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
17681  break;
17682  case MB_ERR_MEMALLOC:
17683  fprintf(stderr, "\t reason: out of memory\n");
17684  break;
17685  case MB_ERR_INTERNAL:
17686  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17687  break;
17688  default:
17689  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
17690  break;
17691  }
17692 
17693 
17694  exit(rc);
17695  }
17696  #endif
17697 }
17698 
17699  /* Delete any search trees */
17700 
17701  rc = MB_Clear(b_employment_status);
17702  #ifdef ERRCHECK
17703  if (rc != MB_SUCCESS)
17704  {
17705  fprintf(stderr, "ERROR: Could not clear 'employment_status' board\n");
17706  switch(rc) {
17707  case MB_ERR_INVALID:
17708  fprintf(stderr, "\t reason: 'employment_status' board is invalid\n");
17709  break;
17710  case MB_ERR_LOCKED:
17711  fprintf(stderr, "\t reason: 'employment_status' board is locked\n");
17712  break;
17713  case MB_ERR_INTERNAL:
17714  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17715  break;
17716  default:
17717  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
17718  break;
17719 
17720  }
17721 
17722 
17723  exit(rc);
17724  }
17725  #endif
17726 
17727  /* DEBUG: States with branching functions */
17728  current_xmachine_household_holder = household_HHConsumptionWeekly_state->agents;
17729  while(current_xmachine_household_holder)
17730  {
17731  FLAME_debug_count = 0;
17732  /* Function: household_consumption_demand */
17733  if(FLAME_condition_household_household_consumption_demand_HHConsumptionWeekly_HHConsumptionRecieveGoods(current_xmachine_household_holder->agent)==1)
17734  { FLAME_debug_count++; }
17735  /* Function: idle */
17736  if(FLAME_condition_household_idle_HHConsumptionWeekly_HHHousingStart(current_xmachine_household_holder->agent)==1)
17737  { FLAME_debug_count++; }
17738  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
17739  if(FLAME_debug_count != 1)
17740  {
17741  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHConsumptionWeekly'\n");
17742  if(FLAME_debug_count > 1)
17743  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
17744  if(FLAME_debug_count == 0)
17745  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
17746  }
17747 
17748  current_xmachine_household_holder = current_xmachine_household_holder->next;
17749  }
17750 
17751  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_consumption_demand\n");
17752  current_xmachine_household_holder = household_HHConsumptionWeekly_state->agents;
17753  while(current_xmachine_household_holder)
17754  {
17755  temp_xmachine_household_holder = current_xmachine_household_holder->next;
17756  current_xmachine_household = current_xmachine_household_holder->agent;
17757  current_xmachine_household_next_state = household_HHConsumptionRecieveGoods_state;
17758  /* For backwards compatibility set current_xmachine */
17759  current_xmachine->xmachine_firm = NULL;
17760  current_xmachine->xmachine_household = NULL;
17761  current_xmachine->xmachine_equityfund = NULL;
17762  current_xmachine->xmachine_bank = NULL;
17763  current_xmachine->xmachine_government = NULL;
17764  current_xmachine->xmachine_centralbank = NULL;
17765  current_xmachine->xmachine_jpoffice = NULL;
17766  current_xmachine->xmachine_mall = NULL;
17767  current_xmachine->xmachine_reagency = NULL;
17768  current_xmachine->xmachine_household = current_xmachine_household;
17769 
17770  if(FLAME_condition_household_household_consumption_demand_HHConsumptionWeekly_HHConsumptionRecieveGoods(current_xmachine_household)==1)
17771  {
17772 
17773 
17774 
17775  i = household_consumption_demand();
17776 
17777 
17778 
17779  if(i == 1)
17780  {
17781  free_household_agent(current_xmachine_household_holder, household_HHConsumptionWeekly_state);
17782  }
17783  else
17784  {
17785  transition_household_agent(current_xmachine_household_holder, household_HHConsumptionWeekly_state, household_HHConsumptionRecieveGoods_state);
17786  }
17787  }
17788 
17789  current_xmachine_household = NULL;
17790 
17791  current_xmachine_household_holder = temp_xmachine_household_holder;
17792  }
17793  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_consumption_demand\n");
17794 
17795  if(FLAME_buy_message_board_write == 1)
17796  {
17797 
17798  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_buy)\n");
17799  rc = MB_SyncStart(b_buy);
17800  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_buy)\n");
17801  #ifdef ERRCHECK
17802  if (rc != MB_SUCCESS)
17803  {
17804  fprintf(stderr, "ERROR: Could not start sync of 'buy' board\n");
17805  switch(rc) {
17806  case MB_ERR_INVALID:
17807  fprintf(stderr, "\t reason: 'buy' board is invalid\n");
17808  break;
17809  case MB_ERR_LOCKED:
17810  fprintf(stderr, "\t reason: 'buy' board is locked\n");
17811  break;
17812  case MB_ERR_MEMALLOC:
17813  fprintf(stderr, "\t reason: out of memory\n");
17814  break;
17815  case MB_ERR_INTERNAL:
17816  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17817  break;
17818  default:
17819  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
17820  break;
17821  }
17822 
17823 
17824  exit(rc);
17825  }
17826  #endif
17827  }
17828 
17829 
17830 
17831  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
17832  current_xmachine_household_holder = household_HHConsumptionWeekly_state->agents;
17833  while(current_xmachine_household_holder)
17834  {
17835  temp_xmachine_household_holder = current_xmachine_household_holder->next;
17836  current_xmachine_household = current_xmachine_household_holder->agent;
17837  current_xmachine_household_next_state = household_HHHousingStart_state;
17838  /* For backwards compatibility set current_xmachine */
17839  current_xmachine->xmachine_firm = NULL;
17840  current_xmachine->xmachine_household = NULL;
17841  current_xmachine->xmachine_equityfund = NULL;
17842  current_xmachine->xmachine_bank = NULL;
17843  current_xmachine->xmachine_government = NULL;
17844  current_xmachine->xmachine_centralbank = NULL;
17845  current_xmachine->xmachine_jpoffice = NULL;
17846  current_xmachine->xmachine_mall = NULL;
17847  current_xmachine->xmachine_reagency = NULL;
17848  current_xmachine->xmachine_household = current_xmachine_household;
17849 
17850  if(FLAME_condition_household_idle_HHConsumptionWeekly_HHHousingStart(current_xmachine_household)==1)
17851  {
17852 
17853 
17854 
17855  i = idle();
17856 
17857 
17858 
17859  if(i == 1)
17860  {
17861  free_household_agent(current_xmachine_household_holder, household_HHConsumptionWeekly_state);
17862  }
17863  else
17864  {
17865  transition_household_agent(current_xmachine_household_holder, household_HHConsumptionWeekly_state, household_HHHousingStart_state);
17866  }
17867  }
17868 
17869  current_xmachine_household = NULL;
17870 
17871  current_xmachine_household_holder = temp_xmachine_household_holder;
17872  }
17873  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
17874 
17875 
17876 /* End of layer number 39 */
17877 
17878 /* Clear message boards that have finished being used
17879  * and sync complete if doing late sync complete */
17880 
17881 
17882  /* If mb is not read then leave sync complete until last possible moment */
17883  if(FLAME_sell_message_board_read == 1)
17884  {
17885  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sell)\n");
17886  rc = MB_SyncComplete(b_sell);
17887  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sell)\n");
17888  #ifdef ERRCHECK
17889  if (rc != MB_SUCCESS)
17890  {
17891  fprintf(stderr, "ERROR: Could not complete sync of 'sell' board\n");
17892  switch(rc) {
17893  case MB_ERR_INVALID:
17894  fprintf(stderr, "\t reason: 'sell' board is invalid\n");
17895  break;
17896  case MB_ERR_MEMALLOC:
17897  fprintf(stderr, "\t reason: out of memory\n");
17898  break;
17899  case MB_ERR_INTERNAL:
17900  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17901  break;
17902  default:
17903  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
17904  break;
17905  }
17906 
17907 
17908  exit(rc);
17909  }
17910  #endif
17911 
17912 
17913 
17914  }
17915 
17916  /* If mb is not read then leave sync complete until last possible moment */
17917  if(FLAME_buy_message_board_read == 1)
17918  {
17919  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_buy)\n");
17920  rc = MB_SyncComplete(b_buy);
17921  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_buy)\n");
17922  #ifdef ERRCHECK
17923  if (rc != MB_SUCCESS)
17924  {
17925  fprintf(stderr, "ERROR: Could not complete sync of 'buy' board\n");
17926  switch(rc) {
17927  case MB_ERR_INVALID:
17928  fprintf(stderr, "\t reason: 'buy' board is invalid\n");
17929  break;
17930  case MB_ERR_MEMALLOC:
17931  fprintf(stderr, "\t reason: out of memory\n");
17932  break;
17933  case MB_ERR_INTERNAL:
17934  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17935  break;
17936  default:
17937  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
17938  break;
17939  }
17940 
17941 
17942  exit(rc);
17943  }
17944  #endif
17945 
17946 
17947 
17948  }
17949 
17950  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start mall_consumption_shopping\n");
17951  current_xmachine_mall_holder = mall_MallConsumptionMarket_state->agents;
17952  while(current_xmachine_mall_holder)
17953  {
17954  temp_xmachine_mall_holder = current_xmachine_mall_holder->next;
17955  current_xmachine_mall = current_xmachine_mall_holder->agent;
17956  current_xmachine_mall_next_state = mall_MallConsumptionSummary_state;
17957  /* For backwards compatibility set current_xmachine */
17958  current_xmachine->xmachine_firm = NULL;
17959  current_xmachine->xmachine_household = NULL;
17960  current_xmachine->xmachine_equityfund = NULL;
17961  current_xmachine->xmachine_bank = NULL;
17962  current_xmachine->xmachine_government = NULL;
17963  current_xmachine->xmachine_centralbank = NULL;
17964  current_xmachine->xmachine_jpoffice = NULL;
17965  current_xmachine->xmachine_mall = NULL;
17966  current_xmachine->xmachine_reagency = NULL;
17967  current_xmachine->xmachine_mall = current_xmachine_mall;
17968 
17969  if(FLAME_condition_mall_mall_consumption_shopping_MallConsumptionMarket_MallConsumptionSummary(current_xmachine_mall)==1)
17970  {
17971 
17972 
17973 
17974 
17975 
17976  rc = MB_Iterator_CreateSorted(b_sell, &i_sell, &FLAME_sort_mall_mall_consumption_shopping_MallConsumptionMarket_MallConsumptionSummary_sell);
17977 
17978  #ifdef ERRCHECK
17979  if (rc != MB_SUCCESS)
17980  {
17981  fprintf(stderr, "ERROR: Could not create Iterator for 'sell'\n");
17982  switch(rc) {
17983  case MB_ERR_INVALID:
17984  fprintf(stderr, "\t reason: 'sell' board is invalid\n");
17985  break;
17986  case MB_ERR_LOCKED:
17987  fprintf(stderr, "\t reason: 'sell' board is locked\n");
17988  break;
17989  case MB_ERR_MEMALLOC:
17990  fprintf(stderr, "\t reason: out of memory\n");
17991  break;
17992  case MB_ERR_INTERNAL:
17993  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
17994  break;
17995  default:
17996 
17997 
17998  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
17999 
18000  break;
18001  }
18002 
18003 
18004  exit(rc);
18005  }
18006  #endif
18007 
18008 
18009 
18010 
18011  rc = MB_Iterator_Create(b_buy, &i_buy);
18012 
18013 
18014  #ifdef ERRCHECK
18015  if (rc != MB_SUCCESS)
18016  {
18017  fprintf(stderr, "ERROR: Could not create Iterator for 'buy'\n");
18018  switch(rc) {
18019  case MB_ERR_INVALID:
18020  fprintf(stderr, "\t reason: 'buy' board is invalid\n");
18021  break;
18022  case MB_ERR_LOCKED:
18023  fprintf(stderr, "\t reason: 'buy' board is locked\n");
18024  break;
18025  case MB_ERR_MEMALLOC:
18026  fprintf(stderr, "\t reason: out of memory\n");
18027  break;
18028  case MB_ERR_INTERNAL:
18029  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18030  break;
18031  default:
18032 
18033 
18034  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
18035 
18036  break;
18037  }
18038 
18039 
18040  exit(rc);
18041  }
18042  #endif
18043  MB_Iterator_Randomise(i_buy);
18044 
18045 
18046  i = mall_consumption_shopping();
18047 
18048 
18049  rc = MB_Iterator_Delete(&i_sell);
18050  #ifdef ERRCHECK
18051  if (rc != MB_SUCCESS)
18052  {
18053  fprintf(stderr, "ERROR: Could not delete 'sell' iterator\n");
18054  switch(rc) {
18055  case MB_ERR_INVALID:
18056  fprintf(stderr, "\t reason: 'sell' iterator is invalid\n");
18057  break;
18058  case MB_ERR_INTERNAL:
18059  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18060  break;
18061  default:
18062  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
18063  break;
18064  }
18065 
18066 
18067  exit(rc);
18068  }
18069  #endif
18070 
18071  rc = MB_Iterator_Delete(&i_buy);
18072  #ifdef ERRCHECK
18073  if (rc != MB_SUCCESS)
18074  {
18075  fprintf(stderr, "ERROR: Could not delete 'buy' iterator\n");
18076  switch(rc) {
18077  case MB_ERR_INVALID:
18078  fprintf(stderr, "\t reason: 'buy' iterator is invalid\n");
18079  break;
18080  case MB_ERR_INTERNAL:
18081  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18082  break;
18083  default:
18084  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
18085  break;
18086  }
18087 
18088 
18089  exit(rc);
18090  }
18091  #endif
18092 
18093 
18094  if(i == 1)
18095  {
18096  free_mall_agent(current_xmachine_mall_holder, mall_MallConsumptionMarket_state);
18097  }
18098  else
18099  {
18100  transition_mall_agent(current_xmachine_mall_holder, mall_MallConsumptionMarket_state, mall_MallConsumptionSummary_state);
18101  }
18102  }
18103 
18104  current_xmachine_mall = NULL;
18105 
18106  current_xmachine_mall_holder = temp_xmachine_mall_holder;
18107  }
18108  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish mall_consumption_shopping\n");
18109 
18110  if(FLAME_sold_message_board_write == 1)
18111  {
18112 
18113  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sold)\n");
18114  rc = MB_SyncStart(b_sold);
18115  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sold)\n");
18116  #ifdef ERRCHECK
18117  if (rc != MB_SUCCESS)
18118  {
18119  fprintf(stderr, "ERROR: Could not start sync of 'sold' board\n");
18120  switch(rc) {
18121  case MB_ERR_INVALID:
18122  fprintf(stderr, "\t reason: 'sold' board is invalid\n");
18123  break;
18124  case MB_ERR_LOCKED:
18125  fprintf(stderr, "\t reason: 'sold' board is locked\n");
18126  break;
18127  case MB_ERR_MEMALLOC:
18128  fprintf(stderr, "\t reason: out of memory\n");
18129  break;
18130  case MB_ERR_INTERNAL:
18131  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18132  break;
18133  default:
18134  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
18135  break;
18136  }
18137 
18138 
18139  exit(rc);
18140  }
18141  #endif
18142  }
18143 
18144 
18145  if(FLAME_bought_message_board_write == 1)
18146  {
18147 
18148  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bought)\n");
18149  rc = MB_SyncStart(b_bought);
18150  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bought)\n");
18151  #ifdef ERRCHECK
18152  if (rc != MB_SUCCESS)
18153  {
18154  fprintf(stderr, "ERROR: Could not start sync of 'bought' board\n");
18155  switch(rc) {
18156  case MB_ERR_INVALID:
18157  fprintf(stderr, "\t reason: 'bought' board is invalid\n");
18158  break;
18159  case MB_ERR_LOCKED:
18160  fprintf(stderr, "\t reason: 'bought' board is locked\n");
18161  break;
18162  case MB_ERR_MEMALLOC:
18163  fprintf(stderr, "\t reason: out of memory\n");
18164  break;
18165  case MB_ERR_INTERNAL:
18166  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18167  break;
18168  default:
18169  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
18170  break;
18171  }
18172 
18173 
18174  exit(rc);
18175  }
18176  #endif
18177  }
18178 
18179 
18180 
18181 /* End of layer number 40 */
18182 
18183 /* Clear message boards that have finished being used
18184  * and sync complete if doing late sync complete */
18185 
18186 if(FLAME_buy_message_board_read == 0)
18187 {
18188  /*printf("%d> buy message board sync complete late as no agents reading any messages of this type\n", node_number);*/
18189 
18190  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_buy)\n");
18191  rc = MB_SyncComplete(b_buy);
18192  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_buy)\n");
18193  #ifdef ERRCHECK
18194  if (rc != MB_SUCCESS)
18195  {
18196  fprintf(stderr, "ERROR: Could not complete sync of 'buy' board\n");
18197  switch(rc) {
18198  case MB_ERR_INVALID:
18199  fprintf(stderr, "\t reason: 'buy' board is invalid\n");
18200  break;
18201  case MB_ERR_MEMALLOC:
18202  fprintf(stderr, "\t reason: out of memory\n");
18203  break;
18204  case MB_ERR_INTERNAL:
18205  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18206  break;
18207  default:
18208  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
18209  break;
18210  }
18211 
18212 
18213  exit(rc);
18214  }
18215  #endif
18216 }
18217 
18218  /* Delete any search trees */
18219 
18220  rc = MB_Clear(b_buy);
18221  #ifdef ERRCHECK
18222  if (rc != MB_SUCCESS)
18223  {
18224  fprintf(stderr, "ERROR: Could not clear 'buy' board\n");
18225  switch(rc) {
18226  case MB_ERR_INVALID:
18227  fprintf(stderr, "\t reason: 'buy' board is invalid\n");
18228  break;
18229  case MB_ERR_LOCKED:
18230  fprintf(stderr, "\t reason: 'buy' board is locked\n");
18231  break;
18232  case MB_ERR_INTERNAL:
18233  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18234  break;
18235  default:
18236  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
18237  break;
18238 
18239  }
18240 
18241 
18242  exit(rc);
18243  }
18244  #endif
18245 
18246 if(FLAME_sell_message_board_read == 0)
18247 {
18248  /*printf("%d> sell message board sync complete late as no agents reading any messages of this type\n", node_number);*/
18249 
18250  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sell)\n");
18251  rc = MB_SyncComplete(b_sell);
18252  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sell)\n");
18253  #ifdef ERRCHECK
18254  if (rc != MB_SUCCESS)
18255  {
18256  fprintf(stderr, "ERROR: Could not complete sync of 'sell' board\n");
18257  switch(rc) {
18258  case MB_ERR_INVALID:
18259  fprintf(stderr, "\t reason: 'sell' board is invalid\n");
18260  break;
18261  case MB_ERR_MEMALLOC:
18262  fprintf(stderr, "\t reason: out of memory\n");
18263  break;
18264  case MB_ERR_INTERNAL:
18265  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18266  break;
18267  default:
18268  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
18269  break;
18270  }
18271 
18272 
18273  exit(rc);
18274  }
18275  #endif
18276 }
18277 
18278  /* Delete any search trees */
18279 
18280  rc = MB_Clear(b_sell);
18281  #ifdef ERRCHECK
18282  if (rc != MB_SUCCESS)
18283  {
18284  fprintf(stderr, "ERROR: Could not clear 'sell' board\n");
18285  switch(rc) {
18286  case MB_ERR_INVALID:
18287  fprintf(stderr, "\t reason: 'sell' board is invalid\n");
18288  break;
18289  case MB_ERR_LOCKED:
18290  fprintf(stderr, "\t reason: 'sell' board is locked\n");
18291  break;
18292  case MB_ERR_INTERNAL:
18293  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18294  break;
18295  default:
18296  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
18297  break;
18298 
18299  }
18300 
18301 
18302  exit(rc);
18303  }
18304  #endif
18305 
18306 
18307  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start mall_consumption_summary\n");
18308  current_xmachine_mall_holder = mall_MallConsumptionSummary_state->agents;
18309  while(current_xmachine_mall_holder)
18310  {
18311  temp_xmachine_mall_holder = current_xmachine_mall_holder->next;
18312  current_xmachine_mall = current_xmachine_mall_holder->agent;
18313  current_xmachine_mall_next_state = mall_end_state;
18314  /* For backwards compatibility set current_xmachine */
18315  current_xmachine->xmachine_firm = NULL;
18316  current_xmachine->xmachine_household = NULL;
18317  current_xmachine->xmachine_equityfund = NULL;
18318  current_xmachine->xmachine_bank = NULL;
18319  current_xmachine->xmachine_government = NULL;
18320  current_xmachine->xmachine_centralbank = NULL;
18321  current_xmachine->xmachine_jpoffice = NULL;
18322  current_xmachine->xmachine_mall = NULL;
18323  current_xmachine->xmachine_reagency = NULL;
18324  current_xmachine->xmachine_mall = current_xmachine_mall;
18325 
18326 
18327 
18328 
18329 
18330  i = mall_consumption_summary();
18331 
18332 
18333 
18334  if(i == 1)
18335  {
18336  free_mall_agent(current_xmachine_mall_holder, mall_MallConsumptionSummary_state);
18337  }
18338  else
18339  {
18340  transition_mall_agent(current_xmachine_mall_holder, mall_MallConsumptionSummary_state, mall_end_state);
18341  }
18342 
18343 
18344  current_xmachine_mall = NULL;
18345 
18346  current_xmachine_mall_holder = temp_xmachine_mall_holder;
18347  }
18348  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish mall_consumption_summary\n");
18349 
18350  if(FLAME_goods_transactions_summary_message_board_write == 1)
18351  {
18352 
18353  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_goods_transactions_summary)\n");
18354  rc = MB_SyncStart(b_goods_transactions_summary);
18355  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_goods_transactions_summary)\n");
18356  #ifdef ERRCHECK
18357  if (rc != MB_SUCCESS)
18358  {
18359  fprintf(stderr, "ERROR: Could not start sync of 'goods_transactions_summary' board\n");
18360  switch(rc) {
18361  case MB_ERR_INVALID:
18362  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
18363  break;
18364  case MB_ERR_LOCKED:
18365  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is locked\n");
18366  break;
18367  case MB_ERR_MEMALLOC:
18368  fprintf(stderr, "\t reason: out of memory\n");
18369  break;
18370  case MB_ERR_INTERNAL:
18371  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18372  break;
18373  default:
18374  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
18375  break;
18376  }
18377 
18378 
18379  exit(rc);
18380  }
18381  #endif
18382  }
18383 
18384 
18385 
18386  /* If mb is not read then leave sync complete until last possible moment */
18387  if(FLAME_sold_message_board_read == 1)
18388  {
18389  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sold)\n");
18390  rc = MB_SyncComplete(b_sold);
18391  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sold)\n");
18392  #ifdef ERRCHECK
18393  if (rc != MB_SUCCESS)
18394  {
18395  fprintf(stderr, "ERROR: Could not complete sync of 'sold' board\n");
18396  switch(rc) {
18397  case MB_ERR_INVALID:
18398  fprintf(stderr, "\t reason: 'sold' board is invalid\n");
18399  break;
18400  case MB_ERR_MEMALLOC:
18401  fprintf(stderr, "\t reason: out of memory\n");
18402  break;
18403  case MB_ERR_INTERNAL:
18404  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18405  break;
18406  default:
18407  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
18408  break;
18409  }
18410 
18411 
18412  exit(rc);
18413  }
18414  #endif
18415 
18416 
18417 
18418  }
18419 
18420  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_consumption_recieve_sales\n");
18421  current_xmachine_firm_holder = firm_FirmRecieveSales_state->agents;
18422  while(current_xmachine_firm_holder)
18423  {
18424  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
18425  current_xmachine_firm = current_xmachine_firm_holder->agent;
18426  current_xmachine_firm_next_state = firm_FirmConsumptionPrice_state;
18427  /* For backwards compatibility set current_xmachine */
18428  current_xmachine->xmachine_firm = NULL;
18429  current_xmachine->xmachine_household = NULL;
18430  current_xmachine->xmachine_equityfund = NULL;
18431  current_xmachine->xmachine_bank = NULL;
18432  current_xmachine->xmachine_government = NULL;
18433  current_xmachine->xmachine_centralbank = NULL;
18434  current_xmachine->xmachine_jpoffice = NULL;
18435  current_xmachine->xmachine_mall = NULL;
18436  current_xmachine->xmachine_reagency = NULL;
18437  current_xmachine->xmachine_firm = current_xmachine_firm;
18438 
18439 
18440 
18441 
18442 
18443 
18444 
18445 
18446  rc = MB_Iterator_CreateFiltered(b_sold, &i_sold, &FLAME_filter_firm_firm_consumption_recieve_sales_FirmRecieveSales_FirmConsumptionPrice_sold, current_xmachine_firm);
18447 
18448 
18449 
18450  #ifdef ERRCHECK
18451  if (rc != MB_SUCCESS)
18452  {
18453  fprintf(stderr, "ERROR: Could not create Iterator for 'sold'\n");
18454  switch(rc) {
18455  case MB_ERR_INVALID:
18456  fprintf(stderr, "\t reason: 'sold' board is invalid\n");
18457  break;
18458  case MB_ERR_LOCKED:
18459  fprintf(stderr, "\t reason: 'sold' board is locked\n");
18460  break;
18461  case MB_ERR_MEMALLOC:
18462  fprintf(stderr, "\t reason: out of memory\n");
18463  break;
18464  case MB_ERR_INTERNAL:
18465  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18466  break;
18467  default:
18468 
18469  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
18470 
18471 
18472  break;
18473  }
18474 
18475 
18476  exit(rc);
18477  }
18478  #endif
18479 
18480 
18481 
18482  i = firm_consumption_recieve_sales();
18483 
18484 
18485  rc = MB_Iterator_Delete(&i_sold);
18486  #ifdef ERRCHECK
18487  if (rc != MB_SUCCESS)
18488  {
18489  fprintf(stderr, "ERROR: Could not delete 'sold' iterator\n");
18490  switch(rc) {
18491  case MB_ERR_INVALID:
18492  fprintf(stderr, "\t reason: 'sold' iterator is invalid\n");
18493  break;
18494  case MB_ERR_INTERNAL:
18495  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18496  break;
18497  default:
18498  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
18499  break;
18500  }
18501 
18502 
18503  exit(rc);
18504  }
18505  #endif
18506 
18507 
18508  if(i == 1)
18509  {
18510  free_firm_agent(current_xmachine_firm_holder, firm_FirmRecieveSales_state);
18511  }
18512  else
18513  {
18514  transition_firm_agent(current_xmachine_firm_holder, firm_FirmRecieveSales_state, firm_FirmConsumptionPrice_state);
18515  }
18516 
18517 
18518  current_xmachine_firm = NULL;
18519 
18520  current_xmachine_firm_holder = temp_xmachine_firm_holder;
18521  }
18522  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_consumption_recieve_sales\n");
18523 
18524 
18525  /* If mb is not read then leave sync complete until last possible moment */
18526  if(FLAME_bought_message_board_read == 1)
18527  {
18528  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bought)\n");
18529  rc = MB_SyncComplete(b_bought);
18530  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bought)\n");
18531  #ifdef ERRCHECK
18532  if (rc != MB_SUCCESS)
18533  {
18534  fprintf(stderr, "ERROR: Could not complete sync of 'bought' board\n");
18535  switch(rc) {
18536  case MB_ERR_INVALID:
18537  fprintf(stderr, "\t reason: 'bought' board is invalid\n");
18538  break;
18539  case MB_ERR_MEMALLOC:
18540  fprintf(stderr, "\t reason: out of memory\n");
18541  break;
18542  case MB_ERR_INTERNAL:
18543  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18544  break;
18545  default:
18546  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
18547  break;
18548  }
18549 
18550 
18551  exit(rc);
18552  }
18553  #endif
18554 
18555 
18556 
18557  }
18558 
18559  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_consumption_recieve_goods\n");
18560  current_xmachine_household_holder = household_HHConsumptionRecieveGoods_state->agents;
18561  while(current_xmachine_household_holder)
18562  {
18563  temp_xmachine_household_holder = current_xmachine_household_holder->next;
18564  current_xmachine_household = current_xmachine_household_holder->agent;
18565  current_xmachine_household_next_state = household_HHHousingStart_state;
18566  /* For backwards compatibility set current_xmachine */
18567  current_xmachine->xmachine_firm = NULL;
18568  current_xmachine->xmachine_household = NULL;
18569  current_xmachine->xmachine_equityfund = NULL;
18570  current_xmachine->xmachine_bank = NULL;
18571  current_xmachine->xmachine_government = NULL;
18572  current_xmachine->xmachine_centralbank = NULL;
18573  current_xmachine->xmachine_jpoffice = NULL;
18574  current_xmachine->xmachine_mall = NULL;
18575  current_xmachine->xmachine_reagency = NULL;
18576  current_xmachine->xmachine_household = current_xmachine_household;
18577 
18578 
18579 
18580 
18581 
18582 
18583 
18584 
18585  rc = MB_Iterator_CreateFiltered(b_bought, &i_bought, &FLAME_filter_household_household_consumption_recieve_goods_HHConsumptionRecieveGoods_HHHousingStart_bought, current_xmachine_household);
18586 
18587 
18588 
18589  #ifdef ERRCHECK
18590  if (rc != MB_SUCCESS)
18591  {
18592  fprintf(stderr, "ERROR: Could not create Iterator for 'bought'\n");
18593  switch(rc) {
18594  case MB_ERR_INVALID:
18595  fprintf(stderr, "\t reason: 'bought' board is invalid\n");
18596  break;
18597  case MB_ERR_LOCKED:
18598  fprintf(stderr, "\t reason: 'bought' board is locked\n");
18599  break;
18600  case MB_ERR_MEMALLOC:
18601  fprintf(stderr, "\t reason: out of memory\n");
18602  break;
18603  case MB_ERR_INTERNAL:
18604  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18605  break;
18606  default:
18607 
18608  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
18609 
18610 
18611  break;
18612  }
18613 
18614 
18615  exit(rc);
18616  }
18617  #endif
18618 
18619 
18620 
18621  i = household_consumption_recieve_goods();
18622 
18623 
18624  rc = MB_Iterator_Delete(&i_bought);
18625  #ifdef ERRCHECK
18626  if (rc != MB_SUCCESS)
18627  {
18628  fprintf(stderr, "ERROR: Could not delete 'bought' iterator\n");
18629  switch(rc) {
18630  case MB_ERR_INVALID:
18631  fprintf(stderr, "\t reason: 'bought' iterator is invalid\n");
18632  break;
18633  case MB_ERR_INTERNAL:
18634  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18635  break;
18636  default:
18637  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
18638  break;
18639  }
18640 
18641 
18642  exit(rc);
18643  }
18644  #endif
18645 
18646 
18647  if(i == 1)
18648  {
18649  free_household_agent(current_xmachine_household_holder, household_HHConsumptionRecieveGoods_state);
18650  }
18651  else
18652  {
18653  transition_household_agent(current_xmachine_household_holder, household_HHConsumptionRecieveGoods_state, household_HHHousingStart_state);
18654  }
18655 
18656 
18657  current_xmachine_household = NULL;
18658 
18659  current_xmachine_household_holder = temp_xmachine_household_holder;
18660  }
18661  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_consumption_recieve_goods\n");
18662 
18663 
18664 /* End of layer number 41 */
18665 
18666 /* Clear message boards that have finished being used
18667  * and sync complete if doing late sync complete */
18668 
18669 if(FLAME_bought_message_board_read == 0)
18670 {
18671  /*printf("%d> bought message board sync complete late as no agents reading any messages of this type\n", node_number);*/
18672 
18673  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bought)\n");
18674  rc = MB_SyncComplete(b_bought);
18675  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bought)\n");
18676  #ifdef ERRCHECK
18677  if (rc != MB_SUCCESS)
18678  {
18679  fprintf(stderr, "ERROR: Could not complete sync of 'bought' board\n");
18680  switch(rc) {
18681  case MB_ERR_INVALID:
18682  fprintf(stderr, "\t reason: 'bought' board is invalid\n");
18683  break;
18684  case MB_ERR_MEMALLOC:
18685  fprintf(stderr, "\t reason: out of memory\n");
18686  break;
18687  case MB_ERR_INTERNAL:
18688  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18689  break;
18690  default:
18691  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
18692  break;
18693  }
18694 
18695 
18696  exit(rc);
18697  }
18698  #endif
18699 }
18700 
18701  /* Delete any search trees */
18702 
18703  rc = MB_Clear(b_bought);
18704  #ifdef ERRCHECK
18705  if (rc != MB_SUCCESS)
18706  {
18707  fprintf(stderr, "ERROR: Could not clear 'bought' board\n");
18708  switch(rc) {
18709  case MB_ERR_INVALID:
18710  fprintf(stderr, "\t reason: 'bought' board is invalid\n");
18711  break;
18712  case MB_ERR_LOCKED:
18713  fprintf(stderr, "\t reason: 'bought' board is locked\n");
18714  break;
18715  case MB_ERR_INTERNAL:
18716  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18717  break;
18718  default:
18719  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
18720  break;
18721 
18722  }
18723 
18724 
18725  exit(rc);
18726  }
18727  #endif
18728 
18729 if(FLAME_sold_message_board_read == 0)
18730 {
18731  /*printf("%d> sold message board sync complete late as no agents reading any messages of this type\n", node_number);*/
18732 
18733  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sold)\n");
18734  rc = MB_SyncComplete(b_sold);
18735  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sold)\n");
18736  #ifdef ERRCHECK
18737  if (rc != MB_SUCCESS)
18738  {
18739  fprintf(stderr, "ERROR: Could not complete sync of 'sold' board\n");
18740  switch(rc) {
18741  case MB_ERR_INVALID:
18742  fprintf(stderr, "\t reason: 'sold' board is invalid\n");
18743  break;
18744  case MB_ERR_MEMALLOC:
18745  fprintf(stderr, "\t reason: out of memory\n");
18746  break;
18747  case MB_ERR_INTERNAL:
18748  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18749  break;
18750  default:
18751  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
18752  break;
18753  }
18754 
18755 
18756  exit(rc);
18757  }
18758  #endif
18759 }
18760 
18761  /* Delete any search trees */
18762 
18763  rc = MB_Clear(b_sold);
18764  #ifdef ERRCHECK
18765  if (rc != MB_SUCCESS)
18766  {
18767  fprintf(stderr, "ERROR: Could not clear 'sold' board\n");
18768  switch(rc) {
18769  case MB_ERR_INVALID:
18770  fprintf(stderr, "\t reason: 'sold' board is invalid\n");
18771  break;
18772  case MB_ERR_LOCKED:
18773  fprintf(stderr, "\t reason: 'sold' board is locked\n");
18774  break;
18775  case MB_ERR_INTERNAL:
18776  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18777  break;
18778  default:
18779  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
18780  break;
18781 
18782  }
18783 
18784 
18785  exit(rc);
18786  }
18787  #endif
18788 
18789  /* DEBUG: States with branching functions */
18790  current_xmachine_household_holder = household_HHHousingStart_state->agents;
18791  while(current_xmachine_household_holder)
18792  {
18793  FLAME_debug_count = 0;
18794  /* Function: household_housing_market_role */
18795  if(FLAME_condition_household_household_housing_market_role_HHHousingStart_HHHousingRole(current_xmachine_household_holder->agent)==1)
18796  { FLAME_debug_count++; }
18797  /* Function: idle */
18798  if(FLAME_condition_household_idle_HHHousingStart_HouseholdUpdateDeposits(current_xmachine_household_holder->agent)==1)
18799  { FLAME_debug_count++; }
18800  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
18801  if(FLAME_debug_count != 1)
18802  {
18803  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHHousingStart'\n");
18804  if(FLAME_debug_count > 1)
18805  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
18806  if(FLAME_debug_count == 0)
18807  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
18808  }
18809 
18810  current_xmachine_household_holder = current_xmachine_household_holder->next;
18811  }
18812 
18813  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_market_role\n");
18814  current_xmachine_household_holder = household_HHHousingStart_state->agents;
18815  while(current_xmachine_household_holder)
18816  {
18817  temp_xmachine_household_holder = current_xmachine_household_holder->next;
18818  current_xmachine_household = current_xmachine_household_holder->agent;
18819  current_xmachine_household_next_state = household_HHHousingRole_state;
18820  /* For backwards compatibility set current_xmachine */
18821  current_xmachine->xmachine_firm = NULL;
18822  current_xmachine->xmachine_household = NULL;
18823  current_xmachine->xmachine_equityfund = NULL;
18824  current_xmachine->xmachine_bank = NULL;
18825  current_xmachine->xmachine_government = NULL;
18826  current_xmachine->xmachine_centralbank = NULL;
18827  current_xmachine->xmachine_jpoffice = NULL;
18828  current_xmachine->xmachine_mall = NULL;
18829  current_xmachine->xmachine_reagency = NULL;
18830  current_xmachine->xmachine_household = current_xmachine_household;
18831 
18832  if(FLAME_condition_household_household_housing_market_role_HHHousingStart_HHHousingRole(current_xmachine_household)==1)
18833  {
18834 
18835 
18836 
18837  i = household_housing_market_role();
18838 
18839 
18840 
18841  if(i == 1)
18842  {
18843  free_household_agent(current_xmachine_household_holder, household_HHHousingStart_state);
18844  }
18845  else
18846  {
18847  transition_household_agent(current_xmachine_household_holder, household_HHHousingStart_state, household_HHHousingRole_state);
18848  }
18849  }
18850 
18851  current_xmachine_household = NULL;
18852 
18853  current_xmachine_household_holder = temp_xmachine_household_holder;
18854  }
18855  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_market_role\n");
18856 
18857 
18858  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
18859  current_xmachine_household_holder = household_HHHousingStart_state->agents;
18860  while(current_xmachine_household_holder)
18861  {
18862  temp_xmachine_household_holder = current_xmachine_household_holder->next;
18863  current_xmachine_household = current_xmachine_household_holder->agent;
18864  current_xmachine_household_next_state = household_HouseholdUpdateDeposits_state;
18865  /* For backwards compatibility set current_xmachine */
18866  current_xmachine->xmachine_firm = NULL;
18867  current_xmachine->xmachine_household = NULL;
18868  current_xmachine->xmachine_equityfund = NULL;
18869  current_xmachine->xmachine_bank = NULL;
18870  current_xmachine->xmachine_government = NULL;
18871  current_xmachine->xmachine_centralbank = NULL;
18872  current_xmachine->xmachine_jpoffice = NULL;
18873  current_xmachine->xmachine_mall = NULL;
18874  current_xmachine->xmachine_reagency = NULL;
18875  current_xmachine->xmachine_household = current_xmachine_household;
18876 
18877  if(FLAME_condition_household_idle_HHHousingStart_HouseholdUpdateDeposits(current_xmachine_household)==1)
18878  {
18879 
18880 
18881 
18882  i = idle();
18883 
18884 
18885 
18886  if(i == 1)
18887  {
18888  free_household_agent(current_xmachine_household_holder, household_HHHousingStart_state);
18889  }
18890  else
18891  {
18892  transition_household_agent(current_xmachine_household_holder, household_HHHousingStart_state, household_HouseholdUpdateDeposits_state);
18893  }
18894  }
18895 
18896  current_xmachine_household = NULL;
18897 
18898  current_xmachine_household_holder = temp_xmachine_household_holder;
18899  }
18900  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
18901 
18902 
18903  /* If mb is not read then leave sync complete until last possible moment */
18904  if(FLAME_goods_transactions_summary_message_board_read == 1)
18905  {
18906  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_goods_transactions_summary)\n");
18907  rc = MB_SyncComplete(b_goods_transactions_summary);
18908  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_goods_transactions_summary)\n");
18909  #ifdef ERRCHECK
18910  if (rc != MB_SUCCESS)
18911  {
18912  fprintf(stderr, "ERROR: Could not complete sync of 'goods_transactions_summary' board\n");
18913  switch(rc) {
18914  case MB_ERR_INVALID:
18915  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
18916  break;
18917  case MB_ERR_MEMALLOC:
18918  fprintf(stderr, "\t reason: out of memory\n");
18919  break;
18920  case MB_ERR_INTERNAL:
18921  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18922  break;
18923  default:
18924  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
18925  break;
18926  }
18927 
18928 
18929  exit(rc);
18930  }
18931  #endif
18932 
18933 
18934 
18935  }
18936 
18937  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_consumption_update_market_price\n");
18938  current_xmachine_firm_holder = firm_FirmConsumptionPrice_state->agents;
18939  while(current_xmachine_firm_holder)
18940  {
18941  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
18942  current_xmachine_firm = current_xmachine_firm_holder->agent;
18943  current_xmachine_firm_next_state = firm_FirmHousingStart_state;
18944  /* For backwards compatibility set current_xmachine */
18945  current_xmachine->xmachine_firm = NULL;
18946  current_xmachine->xmachine_household = NULL;
18947  current_xmachine->xmachine_equityfund = NULL;
18948  current_xmachine->xmachine_bank = NULL;
18949  current_xmachine->xmachine_government = NULL;
18950  current_xmachine->xmachine_centralbank = NULL;
18951  current_xmachine->xmachine_jpoffice = NULL;
18952  current_xmachine->xmachine_mall = NULL;
18953  current_xmachine->xmachine_reagency = NULL;
18954  current_xmachine->xmachine_firm = current_xmachine_firm;
18955 
18956 
18957 
18958 
18959 
18960 
18961  rc = MB_Iterator_Create(b_goods_transactions_summary, &i_goods_transactions_summary);
18962 
18963 
18964  #ifdef ERRCHECK
18965  if (rc != MB_SUCCESS)
18966  {
18967  fprintf(stderr, "ERROR: Could not create Iterator for 'goods_transactions_summary'\n");
18968  switch(rc) {
18969  case MB_ERR_INVALID:
18970  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
18971  break;
18972  case MB_ERR_LOCKED:
18973  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is locked\n");
18974  break;
18975  case MB_ERR_MEMALLOC:
18976  fprintf(stderr, "\t reason: out of memory\n");
18977  break;
18978  case MB_ERR_INTERNAL:
18979  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
18980  break;
18981  default:
18982 
18983 
18984  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
18985 
18986  break;
18987  }
18988 
18989 
18990  exit(rc);
18991  }
18992  #endif
18993 
18994 
18995 
18996  i = firm_consumption_update_market_price();
18997 
18998 
18999  rc = MB_Iterator_Delete(&i_goods_transactions_summary);
19000  #ifdef ERRCHECK
19001  if (rc != MB_SUCCESS)
19002  {
19003  fprintf(stderr, "ERROR: Could not delete 'goods_transactions_summary' iterator\n");
19004  switch(rc) {
19005  case MB_ERR_INVALID:
19006  fprintf(stderr, "\t reason: 'goods_transactions_summary' iterator is invalid\n");
19007  break;
19008  case MB_ERR_INTERNAL:
19009  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19010  break;
19011  default:
19012  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
19013  break;
19014  }
19015 
19016 
19017  exit(rc);
19018  }
19019  #endif
19020 
19021 
19022  if(i == 1)
19023  {
19024  free_firm_agent(current_xmachine_firm_holder, firm_FirmConsumptionPrice_state);
19025  }
19026  else
19027  {
19028  transition_firm_agent(current_xmachine_firm_holder, firm_FirmConsumptionPrice_state, firm_FirmHousingStart_state);
19029  }
19030 
19031 
19032  current_xmachine_firm = NULL;
19033 
19034  current_xmachine_firm_holder = temp_xmachine_firm_holder;
19035  }
19036  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_consumption_update_market_price\n");
19037 
19038 
19039  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_trace_goods_prices\n");
19040  current_xmachine_centralbank_holder = centralbank_CentralBankConsumption_state->agents;
19041  while(current_xmachine_centralbank_holder)
19042  {
19043  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
19044  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
19045  current_xmachine_centralbank_next_state = centralbank_CentralBankHousing_state;
19046  /* For backwards compatibility set current_xmachine */
19047  current_xmachine->xmachine_firm = NULL;
19048  current_xmachine->xmachine_household = NULL;
19049  current_xmachine->xmachine_equityfund = NULL;
19050  current_xmachine->xmachine_bank = NULL;
19051  current_xmachine->xmachine_government = NULL;
19052  current_xmachine->xmachine_centralbank = NULL;
19053  current_xmachine->xmachine_jpoffice = NULL;
19054  current_xmachine->xmachine_mall = NULL;
19055  current_xmachine->xmachine_reagency = NULL;
19056  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
19057 
19058  if(FLAME_condition_centralbank_centralbank_trace_goods_prices_CentralBankConsumption_CentralBankHousing(current_xmachine_centralbank)==1)
19059  {
19060 
19061 
19062 
19063 
19064  rc = MB_Iterator_Create(b_goods_transactions_summary, &i_goods_transactions_summary);
19065 
19066 
19067  #ifdef ERRCHECK
19068  if (rc != MB_SUCCESS)
19069  {
19070  fprintf(stderr, "ERROR: Could not create Iterator for 'goods_transactions_summary'\n");
19071  switch(rc) {
19072  case MB_ERR_INVALID:
19073  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
19074  break;
19075  case MB_ERR_LOCKED:
19076  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is locked\n");
19077  break;
19078  case MB_ERR_MEMALLOC:
19079  fprintf(stderr, "\t reason: out of memory\n");
19080  break;
19081  case MB_ERR_INTERNAL:
19082  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19083  break;
19084  default:
19085 
19086 
19087  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
19088 
19089  break;
19090  }
19091 
19092 
19093  exit(rc);
19094  }
19095  #endif
19096 
19097 
19098 
19099  i = centralbank_trace_goods_prices();
19100 
19101 
19102  rc = MB_Iterator_Delete(&i_goods_transactions_summary);
19103  #ifdef ERRCHECK
19104  if (rc != MB_SUCCESS)
19105  {
19106  fprintf(stderr, "ERROR: Could not delete 'goods_transactions_summary' iterator\n");
19107  switch(rc) {
19108  case MB_ERR_INVALID:
19109  fprintf(stderr, "\t reason: 'goods_transactions_summary' iterator is invalid\n");
19110  break;
19111  case MB_ERR_INTERNAL:
19112  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19113  break;
19114  default:
19115  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
19116  break;
19117  }
19118 
19119 
19120  exit(rc);
19121  }
19122  #endif
19123 
19124 
19125  if(i == 1)
19126  {
19127  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankConsumption_state);
19128  }
19129  else
19130  {
19131  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankConsumption_state, centralbank_CentralBankHousing_state);
19132  }
19133  }
19134 
19135  current_xmachine_centralbank = NULL;
19136 
19137  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
19138  }
19139  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_trace_goods_prices\n");
19140 
19141 
19142 /* End of layer number 42 */
19143 
19144 /* Clear message boards that have finished being used
19145  * and sync complete if doing late sync complete */
19146 
19147 if(FLAME_goods_transactions_summary_message_board_read == 0)
19148 {
19149  /*printf("%d> goods_transactions_summary message board sync complete late as no agents reading any messages of this type\n", node_number);*/
19150 
19151  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_goods_transactions_summary)\n");
19152  rc = MB_SyncComplete(b_goods_transactions_summary);
19153  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_goods_transactions_summary)\n");
19154  #ifdef ERRCHECK
19155  if (rc != MB_SUCCESS)
19156  {
19157  fprintf(stderr, "ERROR: Could not complete sync of 'goods_transactions_summary' board\n");
19158  switch(rc) {
19159  case MB_ERR_INVALID:
19160  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
19161  break;
19162  case MB_ERR_MEMALLOC:
19163  fprintf(stderr, "\t reason: out of memory\n");
19164  break;
19165  case MB_ERR_INTERNAL:
19166  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19167  break;
19168  default:
19169  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
19170  break;
19171  }
19172 
19173 
19174  exit(rc);
19175  }
19176  #endif
19177 }
19178 
19179  /* Delete any search trees */
19180 
19181  rc = MB_Clear(b_goods_transactions_summary);
19182  #ifdef ERRCHECK
19183  if (rc != MB_SUCCESS)
19184  {
19185  fprintf(stderr, "ERROR: Could not clear 'goods_transactions_summary' board\n");
19186  switch(rc) {
19187  case MB_ERR_INVALID:
19188  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is invalid\n");
19189  break;
19190  case MB_ERR_LOCKED:
19191  fprintf(stderr, "\t reason: 'goods_transactions_summary' board is locked\n");
19192  break;
19193  case MB_ERR_INTERNAL:
19194  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19195  break;
19196  default:
19197  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
19198  break;
19199 
19200  }
19201 
19202 
19203  exit(rc);
19204  }
19205  #endif
19206 
19207  /* DEBUG: States with branching functions */
19208  current_xmachine_household_holder = household_HHHousingRole_state->agents;
19209  while(current_xmachine_household_holder)
19210  {
19211  FLAME_debug_count = 0;
19212  /* Function: household_housing_fire_sell */
19213  if(FLAME_condition_household_household_housing_fire_sell_HHHousingRole_HHHousingRevenue(current_xmachine_household_holder->agent)==1)
19214  { FLAME_debug_count++; }
19215  /* Function: household_housing_sell */
19216  if(FLAME_condition_household_household_housing_sell_HHHousingRole_HHHousingRevenue(current_xmachine_household_holder->agent)==1)
19217  { FLAME_debug_count++; }
19218  /* Function: household_housing_check_wealth */
19219  if(FLAME_condition_household_household_housing_check_wealth_HHHousingRole_HHHousingCheckWealth(current_xmachine_household_holder->agent)==1)
19220  { FLAME_debug_count++; }
19221  /* Function: idle */
19222  if(FLAME_condition_household_idle_HHHousingRole_HHHousingPrice(current_xmachine_household_holder->agent)==1)
19223  { FLAME_debug_count++; }
19224  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
19225  if(FLAME_debug_count != 1)
19226  {
19227  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHHousingRole'\n");
19228  if(FLAME_debug_count > 1)
19229  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
19230  if(FLAME_debug_count == 0)
19231  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
19232  }
19233 
19234  current_xmachine_household_holder = current_xmachine_household_holder->next;
19235  }
19236  /* DEBUG: States with branching functions */
19237  current_xmachine_centralbank_holder = centralbank_CentralBankHousing_state->agents;
19238  while(current_xmachine_centralbank_holder)
19239  {
19240  FLAME_debug_count = 0;
19241  /* Function: centralbank_trace_housing_prices */
19242  if(FLAME_condition_centralbank_centralbank_trace_housing_prices_CentralBankHousing_end(current_xmachine_centralbank_holder->agent)==1)
19243  { FLAME_debug_count++; }
19244  /* Function: idle */
19245  if(FLAME_condition_centralbank_idle_CentralBankHousing_end(current_xmachine_centralbank_holder->agent)==1)
19246  { FLAME_debug_count++; }
19247  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
19248  if(FLAME_debug_count != 1)
19249  {
19250  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'centralbank' leaving state 'CentralBankHousing'\n");
19251  if(FLAME_debug_count > 1)
19252  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
19253  if(FLAME_debug_count == 0)
19254  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
19255  }
19256 
19257  current_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
19258  }
19259 
19260  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_sell\n");
19261  current_xmachine_household_holder = household_HHHousingRole_state->agents;
19262  while(current_xmachine_household_holder)
19263  {
19264  temp_xmachine_household_holder = current_xmachine_household_holder->next;
19265  current_xmachine_household = current_xmachine_household_holder->agent;
19266  current_xmachine_household_next_state = household_HHHousingRevenue_state;
19267  /* For backwards compatibility set current_xmachine */
19268  current_xmachine->xmachine_firm = NULL;
19269  current_xmachine->xmachine_household = NULL;
19270  current_xmachine->xmachine_equityfund = NULL;
19271  current_xmachine->xmachine_bank = NULL;
19272  current_xmachine->xmachine_government = NULL;
19273  current_xmachine->xmachine_centralbank = NULL;
19274  current_xmachine->xmachine_jpoffice = NULL;
19275  current_xmachine->xmachine_mall = NULL;
19276  current_xmachine->xmachine_reagency = NULL;
19277  current_xmachine->xmachine_household = current_xmachine_household;
19278 
19279  if(FLAME_condition_household_household_housing_sell_HHHousingRole_HHHousingRevenue(current_xmachine_household)==1)
19280  {
19281 
19282 
19283 
19284  i = household_housing_sell();
19285 
19286 
19287 
19288  if(i == 1)
19289  {
19290  free_household_agent(current_xmachine_household_holder, household_HHHousingRole_state);
19291  }
19292  else
19293  {
19294  transition_household_agent(current_xmachine_household_holder, household_HHHousingRole_state, household_HHHousingRevenue_state);
19295  }
19296  }
19297 
19298  current_xmachine_household = NULL;
19299 
19300  current_xmachine_household_holder = temp_xmachine_household_holder;
19301  }
19302  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_sell\n");
19303 
19304 
19305  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_fire_sell\n");
19306  current_xmachine_household_holder = household_HHHousingRole_state->agents;
19307  while(current_xmachine_household_holder)
19308  {
19309  temp_xmachine_household_holder = current_xmachine_household_holder->next;
19310  current_xmachine_household = current_xmachine_household_holder->agent;
19311  current_xmachine_household_next_state = household_HHHousingRevenue_state;
19312  /* For backwards compatibility set current_xmachine */
19313  current_xmachine->xmachine_firm = NULL;
19314  current_xmachine->xmachine_household = NULL;
19315  current_xmachine->xmachine_equityfund = NULL;
19316  current_xmachine->xmachine_bank = NULL;
19317  current_xmachine->xmachine_government = NULL;
19318  current_xmachine->xmachine_centralbank = NULL;
19319  current_xmachine->xmachine_jpoffice = NULL;
19320  current_xmachine->xmachine_mall = NULL;
19321  current_xmachine->xmachine_reagency = NULL;
19322  current_xmachine->xmachine_household = current_xmachine_household;
19323 
19324  if(FLAME_condition_household_household_housing_fire_sell_HHHousingRole_HHHousingRevenue(current_xmachine_household)==1)
19325  {
19326 
19327 
19328 
19329  i = household_housing_fire_sell();
19330 
19331 
19332 
19333  if(i == 1)
19334  {
19335  free_household_agent(current_xmachine_household_holder, household_HHHousingRole_state);
19336  }
19337  else
19338  {
19339  transition_household_agent(current_xmachine_household_holder, household_HHHousingRole_state, household_HHHousingRevenue_state);
19340  }
19341  }
19342 
19343  current_xmachine_household = NULL;
19344 
19345  current_xmachine_household_holder = temp_xmachine_household_holder;
19346  }
19347  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_fire_sell\n");
19348 
19349 
19350  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
19351  current_xmachine_centralbank_holder = centralbank_CentralBankHousing_state->agents;
19352  while(current_xmachine_centralbank_holder)
19353  {
19354  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
19355  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
19356  current_xmachine_centralbank_next_state = centralbank_end_state;
19357  /* For backwards compatibility set current_xmachine */
19358  current_xmachine->xmachine_firm = NULL;
19359  current_xmachine->xmachine_household = NULL;
19360  current_xmachine->xmachine_equityfund = NULL;
19361  current_xmachine->xmachine_bank = NULL;
19362  current_xmachine->xmachine_government = NULL;
19363  current_xmachine->xmachine_centralbank = NULL;
19364  current_xmachine->xmachine_jpoffice = NULL;
19365  current_xmachine->xmachine_mall = NULL;
19366  current_xmachine->xmachine_reagency = NULL;
19367  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
19368 
19369  if(FLAME_condition_centralbank_idle_CentralBankHousing_end(current_xmachine_centralbank)==1)
19370  {
19371 
19372 
19373 
19374  i = idle();
19375 
19376 
19377 
19378  if(i == 1)
19379  {
19380  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankHousing_state);
19381  }
19382  else
19383  {
19384  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankHousing_state, centralbank_end_state);
19385  }
19386  }
19387 
19388  current_xmachine_centralbank = NULL;
19389 
19390  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
19391  }
19392  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
19393 
19394 
19395  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_check_wealth\n");
19396  current_xmachine_household_holder = household_HHHousingRole_state->agents;
19397  while(current_xmachine_household_holder)
19398  {
19399  temp_xmachine_household_holder = current_xmachine_household_holder->next;
19400  current_xmachine_household = current_xmachine_household_holder->agent;
19401  current_xmachine_household_next_state = household_HHHousingCheckWealth_state;
19402  /* For backwards compatibility set current_xmachine */
19403  current_xmachine->xmachine_firm = NULL;
19404  current_xmachine->xmachine_household = NULL;
19405  current_xmachine->xmachine_equityfund = NULL;
19406  current_xmachine->xmachine_bank = NULL;
19407  current_xmachine->xmachine_government = NULL;
19408  current_xmachine->xmachine_centralbank = NULL;
19409  current_xmachine->xmachine_jpoffice = NULL;
19410  current_xmachine->xmachine_mall = NULL;
19411  current_xmachine->xmachine_reagency = NULL;
19412  current_xmachine->xmachine_household = current_xmachine_household;
19413 
19414  if(FLAME_condition_household_household_housing_check_wealth_HHHousingRole_HHHousingCheckWealth(current_xmachine_household)==1)
19415  {
19416 
19417 
19418 
19419  i = household_housing_check_wealth();
19420 
19421 
19422 
19423  if(i == 1)
19424  {
19425  free_household_agent(current_xmachine_household_holder, household_HHHousingRole_state);
19426  }
19427  else
19428  {
19429  transition_household_agent(current_xmachine_household_holder, household_HHHousingRole_state, household_HHHousingCheckWealth_state);
19430  }
19431  }
19432 
19433  current_xmachine_household = NULL;
19434 
19435  current_xmachine_household_holder = temp_xmachine_household_holder;
19436  }
19437  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_check_wealth\n");
19438 
19439 
19440  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
19441  current_xmachine_household_holder = household_HHHousingRole_state->agents;
19442  while(current_xmachine_household_holder)
19443  {
19444  temp_xmachine_household_holder = current_xmachine_household_holder->next;
19445  current_xmachine_household = current_xmachine_household_holder->agent;
19446  current_xmachine_household_next_state = household_HHHousingPrice_state;
19447  /* For backwards compatibility set current_xmachine */
19448  current_xmachine->xmachine_firm = NULL;
19449  current_xmachine->xmachine_household = NULL;
19450  current_xmachine->xmachine_equityfund = NULL;
19451  current_xmachine->xmachine_bank = NULL;
19452  current_xmachine->xmachine_government = NULL;
19453  current_xmachine->xmachine_centralbank = NULL;
19454  current_xmachine->xmachine_jpoffice = NULL;
19455  current_xmachine->xmachine_mall = NULL;
19456  current_xmachine->xmachine_reagency = NULL;
19457  current_xmachine->xmachine_household = current_xmachine_household;
19458 
19459  if(FLAME_condition_household_idle_HHHousingRole_HHHousingPrice(current_xmachine_household)==1)
19460  {
19461 
19462 
19463 
19464  i = idle();
19465 
19466 
19467 
19468  if(i == 1)
19469  {
19470  free_household_agent(current_xmachine_household_holder, household_HHHousingRole_state);
19471  }
19472  else
19473  {
19474  transition_household_agent(current_xmachine_household_holder, household_HHHousingRole_state, household_HHHousingPrice_state);
19475  }
19476  }
19477 
19478  current_xmachine_household = NULL;
19479 
19480  current_xmachine_household_holder = temp_xmachine_household_holder;
19481  }
19482  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
19483 
19484 
19485  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
19486  current_xmachine_firm_holder = firm_FirmHousingStart_state->agents;
19487  while(current_xmachine_firm_holder)
19488  {
19489  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
19490  current_xmachine_firm = current_xmachine_firm_holder->agent;
19491  current_xmachine_firm_next_state = firm_FirmHousingMarket_state;
19492  /* For backwards compatibility set current_xmachine */
19493  current_xmachine->xmachine_firm = NULL;
19494  current_xmachine->xmachine_household = NULL;
19495  current_xmachine->xmachine_equityfund = NULL;
19496  current_xmachine->xmachine_bank = NULL;
19497  current_xmachine->xmachine_government = NULL;
19498  current_xmachine->xmachine_centralbank = NULL;
19499  current_xmachine->xmachine_jpoffice = NULL;
19500  current_xmachine->xmachine_mall = NULL;
19501  current_xmachine->xmachine_reagency = NULL;
19502  current_xmachine->xmachine_firm = current_xmachine_firm;
19503 
19504  if(FLAME_condition_firm_idle_FirmHousingStart_FirmHousingMarket(current_xmachine_firm)==1)
19505  {
19506 
19507 
19508 
19509  i = idle();
19510 
19511 
19512 
19513  if(i == 1)
19514  {
19515  free_firm_agent(current_xmachine_firm_holder, firm_FirmHousingStart_state);
19516  }
19517  else
19518  {
19519  transition_firm_agent(current_xmachine_firm_holder, firm_FirmHousingStart_state, firm_FirmHousingMarket_state);
19520  }
19521  }
19522 
19523  current_xmachine_firm = NULL;
19524 
19525  current_xmachine_firm_holder = temp_xmachine_firm_holder;
19526  }
19527  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
19528 
19529 
19530  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
19531  current_xmachine_firm_holder = firm_FirmHousingStart_state->agents;
19532  while(current_xmachine_firm_holder)
19533  {
19534  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
19535  current_xmachine_firm = current_xmachine_firm_holder->agent;
19536  current_xmachine_firm_next_state = firm_FirmUpdateDeposits_state;
19537  /* For backwards compatibility set current_xmachine */
19538  current_xmachine->xmachine_firm = NULL;
19539  current_xmachine->xmachine_household = NULL;
19540  current_xmachine->xmachine_equityfund = NULL;
19541  current_xmachine->xmachine_bank = NULL;
19542  current_xmachine->xmachine_government = NULL;
19543  current_xmachine->xmachine_centralbank = NULL;
19544  current_xmachine->xmachine_jpoffice = NULL;
19545  current_xmachine->xmachine_mall = NULL;
19546  current_xmachine->xmachine_reagency = NULL;
19547  current_xmachine->xmachine_firm = current_xmachine_firm;
19548 
19549  if(FLAME_condition_firm_idle_FirmHousingStart_FirmUpdateDeposits(current_xmachine_firm)==1)
19550  {
19551 
19552 
19553 
19554  i = idle();
19555 
19556 
19557 
19558  if(i == 1)
19559  {
19560  free_firm_agent(current_xmachine_firm_holder, firm_FirmHousingStart_state);
19561  }
19562  else
19563  {
19564  transition_firm_agent(current_xmachine_firm_holder, firm_FirmHousingStart_state, firm_FirmUpdateDeposits_state);
19565  }
19566  }
19567 
19568  current_xmachine_firm = NULL;
19569 
19570  current_xmachine_firm_holder = temp_xmachine_firm_holder;
19571  }
19572  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
19573 
19574 
19575 /* End of layer number 43 */
19576 
19577 /* Clear message boards that have finished being used
19578  * and sync complete if doing late sync complete */
19579 
19580  /* DEBUG: States with branching functions */
19581  current_xmachine_firm_holder = firm_FirmHousingMarket_state->agents;
19582  while(current_xmachine_firm_holder)
19583  {
19584  FLAME_debug_count = 0;
19585  /* Function: firm_housing_enter_market */
19586  if(FLAME_condition_firm_firm_housing_enter_market_FirmHousingMarket_FirmHousingSell(current_xmachine_firm_holder->agent)==1)
19587  { FLAME_debug_count++; }
19588  /* Function: idle */
19589  if(FLAME_condition_firm_idle_FirmHousingMarket_FirmUpdateDeposits(current_xmachine_firm_holder->agent)==1)
19590  { FLAME_debug_count++; }
19591  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
19592  if(FLAME_debug_count != 1)
19593  {
19594  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmHousingMarket'\n");
19595  if(FLAME_debug_count > 1)
19596  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
19597  if(FLAME_debug_count == 0)
19598  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
19599  }
19600 
19601  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
19602  }
19603  /* DEBUG: States with branching functions */
19604  current_xmachine_household_holder = household_HHHousingCheckWealth_state->agents;
19605  while(current_xmachine_household_holder)
19606  {
19607  FLAME_debug_count = 0;
19608  /* Function: household_housing_enter_market */
19609  if(FLAME_condition_household_household_housing_enter_market_HHHousingCheckWealth_HHHousingBargain(current_xmachine_household_holder->agent)==1)
19610  { FLAME_debug_count++; }
19611  /* Function: idle */
19612  if(FLAME_condition_household_idle_HHHousingCheckWealth_HHHousingPrice(current_xmachine_household_holder->agent)==1)
19613  { FLAME_debug_count++; }
19614  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
19615  if(FLAME_debug_count != 1)
19616  {
19617  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HHHousingCheckWealth'\n");
19618  if(FLAME_debug_count > 1)
19619  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
19620  if(FLAME_debug_count == 0)
19621  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
19622  }
19623 
19624  current_xmachine_household_holder = current_xmachine_household_holder->next;
19625  }
19626 
19627  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_housing_enter_market\n");
19628  current_xmachine_firm_holder = firm_FirmHousingMarket_state->agents;
19629  while(current_xmachine_firm_holder)
19630  {
19631  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
19632  current_xmachine_firm = current_xmachine_firm_holder->agent;
19633  current_xmachine_firm_next_state = firm_FirmHousingSell_state;
19634  /* For backwards compatibility set current_xmachine */
19635  current_xmachine->xmachine_firm = NULL;
19636  current_xmachine->xmachine_household = NULL;
19637  current_xmachine->xmachine_equityfund = NULL;
19638  current_xmachine->xmachine_bank = NULL;
19639  current_xmachine->xmachine_government = NULL;
19640  current_xmachine->xmachine_centralbank = NULL;
19641  current_xmachine->xmachine_jpoffice = NULL;
19642  current_xmachine->xmachine_mall = NULL;
19643  current_xmachine->xmachine_reagency = NULL;
19644  current_xmachine->xmachine_firm = current_xmachine_firm;
19645 
19646  if(FLAME_condition_firm_firm_housing_enter_market_FirmHousingMarket_FirmHousingSell(current_xmachine_firm)==1)
19647  {
19648 
19649 
19650 
19651  i = firm_housing_enter_market();
19652 
19653 
19654 
19655  if(i == 1)
19656  {
19657  free_firm_agent(current_xmachine_firm_holder, firm_FirmHousingMarket_state);
19658  }
19659  else
19660  {
19661  transition_firm_agent(current_xmachine_firm_holder, firm_FirmHousingMarket_state, firm_FirmHousingSell_state);
19662  }
19663  }
19664 
19665  current_xmachine_firm = NULL;
19666 
19667  current_xmachine_firm_holder = temp_xmachine_firm_holder;
19668  }
19669  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_housing_enter_market\n");
19670 
19671  if(FLAME_sell_housing_message_board_write == 1)
19672  {
19673 
19674  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sell_housing)\n");
19675  rc = MB_SyncStart(b_sell_housing);
19676  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sell_housing)\n");
19677  #ifdef ERRCHECK
19678  if (rc != MB_SUCCESS)
19679  {
19680  fprintf(stderr, "ERROR: Could not start sync of 'sell_housing' board\n");
19681  switch(rc) {
19682  case MB_ERR_INVALID:
19683  fprintf(stderr, "\t reason: 'sell_housing' board is invalid\n");
19684  break;
19685  case MB_ERR_LOCKED:
19686  fprintf(stderr, "\t reason: 'sell_housing' board is locked\n");
19687  break;
19688  case MB_ERR_MEMALLOC:
19689  fprintf(stderr, "\t reason: out of memory\n");
19690  break;
19691  case MB_ERR_INTERNAL:
19692  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19693  break;
19694  default:
19695  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
19696  break;
19697  }
19698 
19699 
19700  exit(rc);
19701  }
19702  #endif
19703  }
19704 
19705 
19706 
19707  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_enter_market\n");
19708  current_xmachine_household_holder = household_HHHousingCheckWealth_state->agents;
19709  while(current_xmachine_household_holder)
19710  {
19711  temp_xmachine_household_holder = current_xmachine_household_holder->next;
19712  current_xmachine_household = current_xmachine_household_holder->agent;
19713  current_xmachine_household_next_state = household_HHHousingBargain_state;
19714  /* For backwards compatibility set current_xmachine */
19715  current_xmachine->xmachine_firm = NULL;
19716  current_xmachine->xmachine_household = NULL;
19717  current_xmachine->xmachine_equityfund = NULL;
19718  current_xmachine->xmachine_bank = NULL;
19719  current_xmachine->xmachine_government = NULL;
19720  current_xmachine->xmachine_centralbank = NULL;
19721  current_xmachine->xmachine_jpoffice = NULL;
19722  current_xmachine->xmachine_mall = NULL;
19723  current_xmachine->xmachine_reagency = NULL;
19724  current_xmachine->xmachine_household = current_xmachine_household;
19725 
19726  if(FLAME_condition_household_household_housing_enter_market_HHHousingCheckWealth_HHHousingBargain(current_xmachine_household)==1)
19727  {
19728 
19729 
19730 
19731  i = household_housing_enter_market();
19732 
19733 
19734 
19735  if(i == 1)
19736  {
19737  free_household_agent(current_xmachine_household_holder, household_HHHousingCheckWealth_state);
19738  }
19739  else
19740  {
19741  transition_household_agent(current_xmachine_household_holder, household_HHHousingCheckWealth_state, household_HHHousingBargain_state);
19742  }
19743  }
19744 
19745  current_xmachine_household = NULL;
19746 
19747  current_xmachine_household_holder = temp_xmachine_household_holder;
19748  }
19749  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_enter_market\n");
19750 
19751  if(FLAME_buy_housing_message_board_write == 1)
19752  {
19753 
19754  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_buy_housing)\n");
19755  rc = MB_SyncStart(b_buy_housing);
19756  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_buy_housing)\n");
19757  #ifdef ERRCHECK
19758  if (rc != MB_SUCCESS)
19759  {
19760  fprintf(stderr, "ERROR: Could not start sync of 'buy_housing' board\n");
19761  switch(rc) {
19762  case MB_ERR_INVALID:
19763  fprintf(stderr, "\t reason: 'buy_housing' board is invalid\n");
19764  break;
19765  case MB_ERR_LOCKED:
19766  fprintf(stderr, "\t reason: 'buy_housing' board is locked\n");
19767  break;
19768  case MB_ERR_MEMALLOC:
19769  fprintf(stderr, "\t reason: out of memory\n");
19770  break;
19771  case MB_ERR_INTERNAL:
19772  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19773  break;
19774  default:
19775  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
19776  break;
19777  }
19778 
19779 
19780  exit(rc);
19781  }
19782  #endif
19783  }
19784 
19785 
19786 
19787  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
19788  current_xmachine_household_holder = household_HHHousingCheckWealth_state->agents;
19789  while(current_xmachine_household_holder)
19790  {
19791  temp_xmachine_household_holder = current_xmachine_household_holder->next;
19792  current_xmachine_household = current_xmachine_household_holder->agent;
19793  current_xmachine_household_next_state = household_HHHousingPrice_state;
19794  /* For backwards compatibility set current_xmachine */
19795  current_xmachine->xmachine_firm = NULL;
19796  current_xmachine->xmachine_household = NULL;
19797  current_xmachine->xmachine_equityfund = NULL;
19798  current_xmachine->xmachine_bank = NULL;
19799  current_xmachine->xmachine_government = NULL;
19800  current_xmachine->xmachine_centralbank = NULL;
19801  current_xmachine->xmachine_jpoffice = NULL;
19802  current_xmachine->xmachine_mall = NULL;
19803  current_xmachine->xmachine_reagency = NULL;
19804  current_xmachine->xmachine_household = current_xmachine_household;
19805 
19806  if(FLAME_condition_household_idle_HHHousingCheckWealth_HHHousingPrice(current_xmachine_household)==1)
19807  {
19808 
19809 
19810 
19811  i = idle();
19812 
19813 
19814 
19815  if(i == 1)
19816  {
19817  free_household_agent(current_xmachine_household_holder, household_HHHousingCheckWealth_state);
19818  }
19819  else
19820  {
19821  transition_household_agent(current_xmachine_household_holder, household_HHHousingCheckWealth_state, household_HHHousingPrice_state);
19822  }
19823  }
19824 
19825  current_xmachine_household = NULL;
19826 
19827  current_xmachine_household_holder = temp_xmachine_household_holder;
19828  }
19829  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
19830 
19831 
19832  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
19833  current_xmachine_firm_holder = firm_FirmHousingMarket_state->agents;
19834  while(current_xmachine_firm_holder)
19835  {
19836  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
19837  current_xmachine_firm = current_xmachine_firm_holder->agent;
19838  current_xmachine_firm_next_state = firm_FirmUpdateDeposits_state;
19839  /* For backwards compatibility set current_xmachine */
19840  current_xmachine->xmachine_firm = NULL;
19841  current_xmachine->xmachine_household = NULL;
19842  current_xmachine->xmachine_equityfund = NULL;
19843  current_xmachine->xmachine_bank = NULL;
19844  current_xmachine->xmachine_government = NULL;
19845  current_xmachine->xmachine_centralbank = NULL;
19846  current_xmachine->xmachine_jpoffice = NULL;
19847  current_xmachine->xmachine_mall = NULL;
19848  current_xmachine->xmachine_reagency = NULL;
19849  current_xmachine->xmachine_firm = current_xmachine_firm;
19850 
19851  if(FLAME_condition_firm_idle_FirmHousingMarket_FirmUpdateDeposits(current_xmachine_firm)==1)
19852  {
19853 
19854 
19855 
19856  i = idle();
19857 
19858 
19859 
19860  if(i == 1)
19861  {
19862  free_firm_agent(current_xmachine_firm_holder, firm_FirmHousingMarket_state);
19863  }
19864  else
19865  {
19866  transition_firm_agent(current_xmachine_firm_holder, firm_FirmHousingMarket_state, firm_FirmUpdateDeposits_state);
19867  }
19868  }
19869 
19870  current_xmachine_firm = NULL;
19871 
19872  current_xmachine_firm_holder = temp_xmachine_firm_holder;
19873  }
19874  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
19875 
19876 
19877 /* End of layer number 44 */
19878 
19879 /* Clear message boards that have finished being used
19880  * and sync complete if doing late sync complete */
19881 
19882 
19883  /* If mb is not read then leave sync complete until last possible moment */
19884  if(FLAME_mortgaging_capacity_message_board_read == 1)
19885  {
19886  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgaging_capacity)\n");
19887  rc = MB_SyncComplete(b_mortgaging_capacity);
19888  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgaging_capacity)\n");
19889  #ifdef ERRCHECK
19890  if (rc != MB_SUCCESS)
19891  {
19892  fprintf(stderr, "ERROR: Could not complete sync of 'mortgaging_capacity' board\n");
19893  switch(rc) {
19894  case MB_ERR_INVALID:
19895  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is invalid\n");
19896  break;
19897  case MB_ERR_MEMALLOC:
19898  fprintf(stderr, "\t reason: out of memory\n");
19899  break;
19900  case MB_ERR_INTERNAL:
19901  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19902  break;
19903  default:
19904  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
19905  break;
19906  }
19907 
19908 
19909  exit(rc);
19910  }
19911  #endif
19912 
19913 
19914 
19915  }
19916 
19917  /* If mb is not read then leave sync complete until last possible moment */
19918  if(FLAME_sell_housing_message_board_read == 1)
19919  {
19920  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sell_housing)\n");
19921  rc = MB_SyncComplete(b_sell_housing);
19922  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sell_housing)\n");
19923  #ifdef ERRCHECK
19924  if (rc != MB_SUCCESS)
19925  {
19926  fprintf(stderr, "ERROR: Could not complete sync of 'sell_housing' board\n");
19927  switch(rc) {
19928  case MB_ERR_INVALID:
19929  fprintf(stderr, "\t reason: 'sell_housing' board is invalid\n");
19930  break;
19931  case MB_ERR_MEMALLOC:
19932  fprintf(stderr, "\t reason: out of memory\n");
19933  break;
19934  case MB_ERR_INTERNAL:
19935  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19936  break;
19937  default:
19938  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
19939  break;
19940  }
19941 
19942 
19943  exit(rc);
19944  }
19945  #endif
19946 
19947 
19948 
19949  }
19950 
19951  /* If mb is not read then leave sync complete until last possible moment */
19952  if(FLAME_buy_housing_message_board_read == 1)
19953  {
19954  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_buy_housing)\n");
19955  rc = MB_SyncComplete(b_buy_housing);
19956  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_buy_housing)\n");
19957  #ifdef ERRCHECK
19958  if (rc != MB_SUCCESS)
19959  {
19960  fprintf(stderr, "ERROR: Could not complete sync of 'buy_housing' board\n");
19961  switch(rc) {
19962  case MB_ERR_INVALID:
19963  fprintf(stderr, "\t reason: 'buy_housing' board is invalid\n");
19964  break;
19965  case MB_ERR_MEMALLOC:
19966  fprintf(stderr, "\t reason: out of memory\n");
19967  break;
19968  case MB_ERR_INTERNAL:
19969  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
19970  break;
19971  default:
19972  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
19973  break;
19974  }
19975 
19976 
19977  exit(rc);
19978  }
19979  #endif
19980 
19981 
19982 
19983  }
19984 
19985  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start reagency_housing_process\n");
19986  current_xmachine_reagency_holder = reagency_REAgencyHousingProcess_state->agents;
19987  while(current_xmachine_reagency_holder)
19988  {
19989  temp_xmachine_reagency_holder = current_xmachine_reagency_holder->next;
19990  current_xmachine_reagency = current_xmachine_reagency_holder->agent;
19991  current_xmachine_reagency_next_state = reagency_REAgencyHousingSummary_state;
19992  /* For backwards compatibility set current_xmachine */
19993  current_xmachine->xmachine_firm = NULL;
19994  current_xmachine->xmachine_household = NULL;
19995  current_xmachine->xmachine_equityfund = NULL;
19996  current_xmachine->xmachine_bank = NULL;
19997  current_xmachine->xmachine_government = NULL;
19998  current_xmachine->xmachine_centralbank = NULL;
19999  current_xmachine->xmachine_jpoffice = NULL;
20000  current_xmachine->xmachine_mall = NULL;
20001  current_xmachine->xmachine_reagency = NULL;
20002  current_xmachine->xmachine_reagency = current_xmachine_reagency;
20003 
20004 
20005 
20006 
20007 
20008 
20009  rc = MB_Iterator_Create(b_buy_housing, &i_buy_housing);
20010 
20011 
20012  #ifdef ERRCHECK
20013  if (rc != MB_SUCCESS)
20014  {
20015  fprintf(stderr, "ERROR: Could not create Iterator for 'buy_housing'\n");
20016  switch(rc) {
20017  case MB_ERR_INVALID:
20018  fprintf(stderr, "\t reason: 'buy_housing' board is invalid\n");
20019  break;
20020  case MB_ERR_LOCKED:
20021  fprintf(stderr, "\t reason: 'buy_housing' board is locked\n");
20022  break;
20023  case MB_ERR_MEMALLOC:
20024  fprintf(stderr, "\t reason: out of memory\n");
20025  break;
20026  case MB_ERR_INTERNAL:
20027  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20028  break;
20029  default:
20030 
20031 
20032  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
20033 
20034  break;
20035  }
20036 
20037 
20038  exit(rc);
20039  }
20040  #endif
20041  MB_Iterator_Randomise(i_buy_housing);
20042 
20043 
20044 
20045 
20046  rc = MB_Iterator_CreateSorted(b_sell_housing, &i_sell_housing, &FLAME_sort_reagency_reagency_housing_process_REAgencyHousingProcess_REAgencyHousingSummary_sell_housing);
20047 
20048  #ifdef ERRCHECK
20049  if (rc != MB_SUCCESS)
20050  {
20051  fprintf(stderr, "ERROR: Could not create Iterator for 'sell_housing'\n");
20052  switch(rc) {
20053  case MB_ERR_INVALID:
20054  fprintf(stderr, "\t reason: 'sell_housing' board is invalid\n");
20055  break;
20056  case MB_ERR_LOCKED:
20057  fprintf(stderr, "\t reason: 'sell_housing' board is locked\n");
20058  break;
20059  case MB_ERR_MEMALLOC:
20060  fprintf(stderr, "\t reason: out of memory\n");
20061  break;
20062  case MB_ERR_INTERNAL:
20063  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20064  break;
20065  default:
20066 
20067 
20068  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
20069 
20070  break;
20071  }
20072 
20073 
20074  exit(rc);
20075  }
20076  #endif
20077 
20078 
20079 
20080 
20081 
20082  rc = MB_Iterator_CreateSorted(b_mortgaging_capacity, &i_mortgaging_capacity, &FLAME_sort_reagency_reagency_housing_process_REAgencyHousingProcess_REAgencyHousingSummary_mortgaging_capacity);
20083 
20084  #ifdef ERRCHECK
20085  if (rc != MB_SUCCESS)
20086  {
20087  fprintf(stderr, "ERROR: Could not create Iterator for 'mortgaging_capacity'\n");
20088  switch(rc) {
20089  case MB_ERR_INVALID:
20090  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is invalid\n");
20091  break;
20092  case MB_ERR_LOCKED:
20093  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is locked\n");
20094  break;
20095  case MB_ERR_MEMALLOC:
20096  fprintf(stderr, "\t reason: out of memory\n");
20097  break;
20098  case MB_ERR_INTERNAL:
20099  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20100  break;
20101  default:
20102 
20103 
20104  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
20105 
20106  break;
20107  }
20108 
20109 
20110  exit(rc);
20111  }
20112  #endif
20113 
20114 
20115 
20116  i = reagency_housing_process();
20117 
20118 
20119  rc = MB_Iterator_Delete(&i_buy_housing);
20120  #ifdef ERRCHECK
20121  if (rc != MB_SUCCESS)
20122  {
20123  fprintf(stderr, "ERROR: Could not delete 'buy_housing' iterator\n");
20124  switch(rc) {
20125  case MB_ERR_INVALID:
20126  fprintf(stderr, "\t reason: 'buy_housing' iterator is invalid\n");
20127  break;
20128  case MB_ERR_INTERNAL:
20129  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20130  break;
20131  default:
20132  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
20133  break;
20134  }
20135 
20136 
20137  exit(rc);
20138  }
20139  #endif
20140 
20141  rc = MB_Iterator_Delete(&i_sell_housing);
20142  #ifdef ERRCHECK
20143  if (rc != MB_SUCCESS)
20144  {
20145  fprintf(stderr, "ERROR: Could not delete 'sell_housing' iterator\n");
20146  switch(rc) {
20147  case MB_ERR_INVALID:
20148  fprintf(stderr, "\t reason: 'sell_housing' iterator is invalid\n");
20149  break;
20150  case MB_ERR_INTERNAL:
20151  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20152  break;
20153  default:
20154  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
20155  break;
20156  }
20157 
20158 
20159  exit(rc);
20160  }
20161  #endif
20162 
20163  rc = MB_Iterator_Delete(&i_mortgaging_capacity);
20164  #ifdef ERRCHECK
20165  if (rc != MB_SUCCESS)
20166  {
20167  fprintf(stderr, "ERROR: Could not delete 'mortgaging_capacity' iterator\n");
20168  switch(rc) {
20169  case MB_ERR_INVALID:
20170  fprintf(stderr, "\t reason: 'mortgaging_capacity' iterator is invalid\n");
20171  break;
20172  case MB_ERR_INTERNAL:
20173  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20174  break;
20175  default:
20176  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
20177  break;
20178  }
20179 
20180 
20181  exit(rc);
20182  }
20183  #endif
20184 
20185 
20186  if(i == 1)
20187  {
20188  free_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingProcess_state);
20189  }
20190  else
20191  {
20192  transition_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingProcess_state, reagency_REAgencyHousingSummary_state);
20193  }
20194 
20195 
20196  current_xmachine_reagency = NULL;
20197 
20198  current_xmachine_reagency_holder = temp_xmachine_reagency_holder;
20199  }
20200  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish reagency_housing_process\n");
20201 
20202  if(FLAME_mortgage_requests_message_board_write == 1)
20203  {
20204 
20205  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_requests)\n");
20206  rc = MB_SyncStart(b_mortgage_requests);
20207  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_requests)\n");
20208  #ifdef ERRCHECK
20209  if (rc != MB_SUCCESS)
20210  {
20211  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_requests' board\n");
20212  switch(rc) {
20213  case MB_ERR_INVALID:
20214  fprintf(stderr, "\t reason: 'mortgage_requests' board is invalid\n");
20215  break;
20216  case MB_ERR_LOCKED:
20217  fprintf(stderr, "\t reason: 'mortgage_requests' board is locked\n");
20218  break;
20219  case MB_ERR_MEMALLOC:
20220  fprintf(stderr, "\t reason: out of memory\n");
20221  break;
20222  case MB_ERR_INTERNAL:
20223  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20224  break;
20225  default:
20226  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
20227  break;
20228  }
20229 
20230 
20231  exit(rc);
20232  }
20233  #endif
20234  }
20235 
20236 
20237  if(FLAME_sold_housing_message_board_write == 1)
20238  {
20239 
20240  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_sold_housing)\n");
20241  rc = MB_SyncStart(b_sold_housing);
20242  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_sold_housing)\n");
20243  #ifdef ERRCHECK
20244  if (rc != MB_SUCCESS)
20245  {
20246  fprintf(stderr, "ERROR: Could not start sync of 'sold_housing' board\n");
20247  switch(rc) {
20248  case MB_ERR_INVALID:
20249  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
20250  break;
20251  case MB_ERR_LOCKED:
20252  fprintf(stderr, "\t reason: 'sold_housing' board is locked\n");
20253  break;
20254  case MB_ERR_MEMALLOC:
20255  fprintf(stderr, "\t reason: out of memory\n");
20256  break;
20257  case MB_ERR_INTERNAL:
20258  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20259  break;
20260  default:
20261  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
20262  break;
20263  }
20264 
20265 
20266  exit(rc);
20267  }
20268  #endif
20269  }
20270 
20271 
20272  if(FLAME_bought_housing_message_board_write == 1)
20273  {
20274 
20275  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_bought_housing)\n");
20276  rc = MB_SyncStart(b_bought_housing);
20277  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_bought_housing)\n");
20278  #ifdef ERRCHECK
20279  if (rc != MB_SUCCESS)
20280  {
20281  fprintf(stderr, "ERROR: Could not start sync of 'bought_housing' board\n");
20282  switch(rc) {
20283  case MB_ERR_INVALID:
20284  fprintf(stderr, "\t reason: 'bought_housing' board is invalid\n");
20285  break;
20286  case MB_ERR_LOCKED:
20287  fprintf(stderr, "\t reason: 'bought_housing' board is locked\n");
20288  break;
20289  case MB_ERR_MEMALLOC:
20290  fprintf(stderr, "\t reason: out of memory\n");
20291  break;
20292  case MB_ERR_INTERNAL:
20293  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20294  break;
20295  default:
20296  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
20297  break;
20298  }
20299 
20300 
20301  exit(rc);
20302  }
20303  #endif
20304  }
20305 
20306 
20307 
20308 /* End of layer number 45 */
20309 
20310 /* Clear message boards that have finished being used
20311  * and sync complete if doing late sync complete */
20312 
20313 if(FLAME_buy_housing_message_board_read == 0)
20314 {
20315  /*printf("%d> buy_housing message board sync complete late as no agents reading any messages of this type\n", node_number);*/
20316 
20317  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_buy_housing)\n");
20318  rc = MB_SyncComplete(b_buy_housing);
20319  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_buy_housing)\n");
20320  #ifdef ERRCHECK
20321  if (rc != MB_SUCCESS)
20322  {
20323  fprintf(stderr, "ERROR: Could not complete sync of 'buy_housing' board\n");
20324  switch(rc) {
20325  case MB_ERR_INVALID:
20326  fprintf(stderr, "\t reason: 'buy_housing' board is invalid\n");
20327  break;
20328  case MB_ERR_MEMALLOC:
20329  fprintf(stderr, "\t reason: out of memory\n");
20330  break;
20331  case MB_ERR_INTERNAL:
20332  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20333  break;
20334  default:
20335  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
20336  break;
20337  }
20338 
20339 
20340  exit(rc);
20341  }
20342  #endif
20343 }
20344 
20345  /* Delete any search trees */
20346 
20347  rc = MB_Clear(b_buy_housing);
20348  #ifdef ERRCHECK
20349  if (rc != MB_SUCCESS)
20350  {
20351  fprintf(stderr, "ERROR: Could not clear 'buy_housing' board\n");
20352  switch(rc) {
20353  case MB_ERR_INVALID:
20354  fprintf(stderr, "\t reason: 'buy_housing' board is invalid\n");
20355  break;
20356  case MB_ERR_LOCKED:
20357  fprintf(stderr, "\t reason: 'buy_housing' board is locked\n");
20358  break;
20359  case MB_ERR_INTERNAL:
20360  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20361  break;
20362  default:
20363  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
20364  break;
20365 
20366  }
20367 
20368 
20369  exit(rc);
20370  }
20371  #endif
20372 
20373 if(FLAME_sell_housing_message_board_read == 0)
20374 {
20375  /*printf("%d> sell_housing message board sync complete late as no agents reading any messages of this type\n", node_number);*/
20376 
20377  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sell_housing)\n");
20378  rc = MB_SyncComplete(b_sell_housing);
20379  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sell_housing)\n");
20380  #ifdef ERRCHECK
20381  if (rc != MB_SUCCESS)
20382  {
20383  fprintf(stderr, "ERROR: Could not complete sync of 'sell_housing' board\n");
20384  switch(rc) {
20385  case MB_ERR_INVALID:
20386  fprintf(stderr, "\t reason: 'sell_housing' board is invalid\n");
20387  break;
20388  case MB_ERR_MEMALLOC:
20389  fprintf(stderr, "\t reason: out of memory\n");
20390  break;
20391  case MB_ERR_INTERNAL:
20392  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20393  break;
20394  default:
20395  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
20396  break;
20397  }
20398 
20399 
20400  exit(rc);
20401  }
20402  #endif
20403 }
20404 
20405  /* Delete any search trees */
20406 
20407  rc = MB_Clear(b_sell_housing);
20408  #ifdef ERRCHECK
20409  if (rc != MB_SUCCESS)
20410  {
20411  fprintf(stderr, "ERROR: Could not clear 'sell_housing' board\n");
20412  switch(rc) {
20413  case MB_ERR_INVALID:
20414  fprintf(stderr, "\t reason: 'sell_housing' board is invalid\n");
20415  break;
20416  case MB_ERR_LOCKED:
20417  fprintf(stderr, "\t reason: 'sell_housing' board is locked\n");
20418  break;
20419  case MB_ERR_INTERNAL:
20420  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20421  break;
20422  default:
20423  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
20424  break;
20425 
20426  }
20427 
20428 
20429  exit(rc);
20430  }
20431  #endif
20432 
20433 if(FLAME_mortgaging_capacity_message_board_read == 0)
20434 {
20435  /*printf("%d> mortgaging_capacity message board sync complete late as no agents reading any messages of this type\n", node_number);*/
20436 
20437  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgaging_capacity)\n");
20438  rc = MB_SyncComplete(b_mortgaging_capacity);
20439  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgaging_capacity)\n");
20440  #ifdef ERRCHECK
20441  if (rc != MB_SUCCESS)
20442  {
20443  fprintf(stderr, "ERROR: Could not complete sync of 'mortgaging_capacity' board\n");
20444  switch(rc) {
20445  case MB_ERR_INVALID:
20446  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is invalid\n");
20447  break;
20448  case MB_ERR_MEMALLOC:
20449  fprintf(stderr, "\t reason: out of memory\n");
20450  break;
20451  case MB_ERR_INTERNAL:
20452  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20453  break;
20454  default:
20455  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
20456  break;
20457  }
20458 
20459 
20460  exit(rc);
20461  }
20462  #endif
20463 }
20464 
20465  /* Delete any search trees */
20466 
20467  rc = MB_Clear(b_mortgaging_capacity);
20468  #ifdef ERRCHECK
20469  if (rc != MB_SUCCESS)
20470  {
20471  fprintf(stderr, "ERROR: Could not clear 'mortgaging_capacity' board\n");
20472  switch(rc) {
20473  case MB_ERR_INVALID:
20474  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is invalid\n");
20475  break;
20476  case MB_ERR_LOCKED:
20477  fprintf(stderr, "\t reason: 'mortgaging_capacity' board is locked\n");
20478  break;
20479  case MB_ERR_INTERNAL:
20480  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20481  break;
20482  default:
20483  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
20484  break;
20485 
20486  }
20487 
20488 
20489  exit(rc);
20490  }
20491  #endif
20492 
20493 
20494  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start reagency_housing_summary\n");
20495  current_xmachine_reagency_holder = reagency_REAgencyHousingSummary_state->agents;
20496  while(current_xmachine_reagency_holder)
20497  {
20498  temp_xmachine_reagency_holder = current_xmachine_reagency_holder->next;
20499  current_xmachine_reagency = current_xmachine_reagency_holder->agent;
20500  current_xmachine_reagency_next_state = reagency_end_state;
20501  /* For backwards compatibility set current_xmachine */
20502  current_xmachine->xmachine_firm = NULL;
20503  current_xmachine->xmachine_household = NULL;
20504  current_xmachine->xmachine_equityfund = NULL;
20505  current_xmachine->xmachine_bank = NULL;
20506  current_xmachine->xmachine_government = NULL;
20507  current_xmachine->xmachine_centralbank = NULL;
20508  current_xmachine->xmachine_jpoffice = NULL;
20509  current_xmachine->xmachine_mall = NULL;
20510  current_xmachine->xmachine_reagency = NULL;
20511  current_xmachine->xmachine_reagency = current_xmachine_reagency;
20512 
20513 
20514 
20515 
20516 
20517  i = reagency_housing_summary();
20518 
20519 
20520 
20521  if(i == 1)
20522  {
20523  free_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingSummary_state);
20524  }
20525  else
20526  {
20527  transition_reagency_agent(current_xmachine_reagency_holder, reagency_REAgencyHousingSummary_state, reagency_end_state);
20528  }
20529 
20530 
20531  current_xmachine_reagency = NULL;
20532 
20533  current_xmachine_reagency_holder = temp_xmachine_reagency_holder;
20534  }
20535  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish reagency_housing_summary\n");
20536 
20537  if(FLAME_housing_transactions_summary_message_board_write == 1)
20538  {
20539 
20540  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_housing_transactions_summary)\n");
20541  rc = MB_SyncStart(b_housing_transactions_summary);
20542  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_housing_transactions_summary)\n");
20543  #ifdef ERRCHECK
20544  if (rc != MB_SUCCESS)
20545  {
20546  fprintf(stderr, "ERROR: Could not start sync of 'housing_transactions_summary' board\n");
20547  switch(rc) {
20548  case MB_ERR_INVALID:
20549  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is invalid\n");
20550  break;
20551  case MB_ERR_LOCKED:
20552  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is locked\n");
20553  break;
20554  case MB_ERR_MEMALLOC:
20555  fprintf(stderr, "\t reason: out of memory\n");
20556  break;
20557  case MB_ERR_INTERNAL:
20558  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20559  break;
20560  default:
20561  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
20562  break;
20563  }
20564 
20565 
20566  exit(rc);
20567  }
20568  #endif
20569  }
20570 
20571 
20572  if(FLAME_housing_price_message_board_write == 1)
20573  {
20574 
20575  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_housing_price)\n");
20576  rc = MB_SyncStart(b_housing_price);
20577  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_housing_price)\n");
20578  #ifdef ERRCHECK
20579  if (rc != MB_SUCCESS)
20580  {
20581  fprintf(stderr, "ERROR: Could not start sync of 'housing_price' board\n");
20582  switch(rc) {
20583  case MB_ERR_INVALID:
20584  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
20585  break;
20586  case MB_ERR_LOCKED:
20587  fprintf(stderr, "\t reason: 'housing_price' board is locked\n");
20588  break;
20589  case MB_ERR_MEMALLOC:
20590  fprintf(stderr, "\t reason: out of memory\n");
20591  break;
20592  case MB_ERR_INTERNAL:
20593  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20594  break;
20595  default:
20596  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
20597  break;
20598  }
20599 
20600 
20601  exit(rc);
20602  }
20603  #endif
20604  }
20605 
20606 
20607 
20608  /* If mb is not read then leave sync complete until last possible moment */
20609  if(FLAME_sold_housing_message_board_read == 1)
20610  {
20611  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sold_housing)\n");
20612  rc = MB_SyncComplete(b_sold_housing);
20613  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sold_housing)\n");
20614  #ifdef ERRCHECK
20615  if (rc != MB_SUCCESS)
20616  {
20617  fprintf(stderr, "ERROR: Could not complete sync of 'sold_housing' board\n");
20618  switch(rc) {
20619  case MB_ERR_INVALID:
20620  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
20621  break;
20622  case MB_ERR_MEMALLOC:
20623  fprintf(stderr, "\t reason: out of memory\n");
20624  break;
20625  case MB_ERR_INTERNAL:
20626  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20627  break;
20628  default:
20629  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
20630  break;
20631  }
20632 
20633 
20634  exit(rc);
20635  }
20636  #endif
20637 
20638 
20639 
20640  }
20641 
20642  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_housing_collect_sale_revenues\n");
20643  current_xmachine_firm_holder = firm_FirmHousingSell_state->agents;
20644  while(current_xmachine_firm_holder)
20645  {
20646  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
20647  current_xmachine_firm = current_xmachine_firm_holder->agent;
20648  current_xmachine_firm_next_state = firm_FirmHousingPrice_state;
20649  /* For backwards compatibility set current_xmachine */
20650  current_xmachine->xmachine_firm = NULL;
20651  current_xmachine->xmachine_household = NULL;
20652  current_xmachine->xmachine_equityfund = NULL;
20653  current_xmachine->xmachine_bank = NULL;
20654  current_xmachine->xmachine_government = NULL;
20655  current_xmachine->xmachine_centralbank = NULL;
20656  current_xmachine->xmachine_jpoffice = NULL;
20657  current_xmachine->xmachine_mall = NULL;
20658  current_xmachine->xmachine_reagency = NULL;
20659  current_xmachine->xmachine_firm = current_xmachine_firm;
20660 
20661 
20662 
20663 
20664 
20665 
20666 
20667 
20668  rc = MB_Iterator_CreateFiltered(b_sold_housing, &i_sold_housing, &FLAME_filter_firm_firm_housing_collect_sale_revenues_FirmHousingSell_FirmHousingPrice_sold_housing, current_xmachine_firm);
20669 
20670 
20671 
20672  #ifdef ERRCHECK
20673  if (rc != MB_SUCCESS)
20674  {
20675  fprintf(stderr, "ERROR: Could not create Iterator for 'sold_housing'\n");
20676  switch(rc) {
20677  case MB_ERR_INVALID:
20678  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
20679  break;
20680  case MB_ERR_LOCKED:
20681  fprintf(stderr, "\t reason: 'sold_housing' board is locked\n");
20682  break;
20683  case MB_ERR_MEMALLOC:
20684  fprintf(stderr, "\t reason: out of memory\n");
20685  break;
20686  case MB_ERR_INTERNAL:
20687  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20688  break;
20689  default:
20690 
20691  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
20692 
20693 
20694  break;
20695  }
20696 
20697 
20698  exit(rc);
20699  }
20700  #endif
20701 
20702 
20703 
20704  i = firm_housing_collect_sale_revenues();
20705 
20706 
20707  rc = MB_Iterator_Delete(&i_sold_housing);
20708  #ifdef ERRCHECK
20709  if (rc != MB_SUCCESS)
20710  {
20711  fprintf(stderr, "ERROR: Could not delete 'sold_housing' iterator\n");
20712  switch(rc) {
20713  case MB_ERR_INVALID:
20714  fprintf(stderr, "\t reason: 'sold_housing' iterator is invalid\n");
20715  break;
20716  case MB_ERR_INTERNAL:
20717  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20718  break;
20719  default:
20720  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
20721  break;
20722  }
20723 
20724 
20725  exit(rc);
20726  }
20727  #endif
20728 
20729 
20730  if(i == 1)
20731  {
20732  free_firm_agent(current_xmachine_firm_holder, firm_FirmHousingSell_state);
20733  }
20734  else
20735  {
20736  transition_firm_agent(current_xmachine_firm_holder, firm_FirmHousingSell_state, firm_FirmHousingPrice_state);
20737  }
20738 
20739 
20740  current_xmachine_firm = NULL;
20741 
20742  current_xmachine_firm_holder = temp_xmachine_firm_holder;
20743  }
20744  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_housing_collect_sale_revenues\n");
20745 
20746 
20747  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_collect_sale_revenue\n");
20748  current_xmachine_household_holder = household_HHHousingRevenue_state->agents;
20749  while(current_xmachine_household_holder)
20750  {
20751  temp_xmachine_household_holder = current_xmachine_household_holder->next;
20752  current_xmachine_household = current_xmachine_household_holder->agent;
20753  current_xmachine_household_next_state = household_HHHousingPrice_state;
20754  /* For backwards compatibility set current_xmachine */
20755  current_xmachine->xmachine_firm = NULL;
20756  current_xmachine->xmachine_household = NULL;
20757  current_xmachine->xmachine_equityfund = NULL;
20758  current_xmachine->xmachine_bank = NULL;
20759  current_xmachine->xmachine_government = NULL;
20760  current_xmachine->xmachine_centralbank = NULL;
20761  current_xmachine->xmachine_jpoffice = NULL;
20762  current_xmachine->xmachine_mall = NULL;
20763  current_xmachine->xmachine_reagency = NULL;
20764  current_xmachine->xmachine_household = current_xmachine_household;
20765 
20766 
20767 
20768 
20769 
20770 
20771 
20772 
20773  rc = MB_Iterator_CreateFiltered(b_sold_housing, &i_sold_housing, &FLAME_filter_household_household_housing_collect_sale_revenue_HHHousingRevenue_HHHousingPrice_sold_housing, current_xmachine_household);
20774 
20775 
20776 
20777  #ifdef ERRCHECK
20778  if (rc != MB_SUCCESS)
20779  {
20780  fprintf(stderr, "ERROR: Could not create Iterator for 'sold_housing'\n");
20781  switch(rc) {
20782  case MB_ERR_INVALID:
20783  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
20784  break;
20785  case MB_ERR_LOCKED:
20786  fprintf(stderr, "\t reason: 'sold_housing' board is locked\n");
20787  break;
20788  case MB_ERR_MEMALLOC:
20789  fprintf(stderr, "\t reason: out of memory\n");
20790  break;
20791  case MB_ERR_INTERNAL:
20792  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20793  break;
20794  default:
20795 
20796  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
20797 
20798 
20799  break;
20800  }
20801 
20802 
20803  exit(rc);
20804  }
20805  #endif
20806 
20807 
20808 
20809  i = household_housing_collect_sale_revenue();
20810 
20811 
20812  rc = MB_Iterator_Delete(&i_sold_housing);
20813  #ifdef ERRCHECK
20814  if (rc != MB_SUCCESS)
20815  {
20816  fprintf(stderr, "ERROR: Could not delete 'sold_housing' iterator\n");
20817  switch(rc) {
20818  case MB_ERR_INVALID:
20819  fprintf(stderr, "\t reason: 'sold_housing' iterator is invalid\n");
20820  break;
20821  case MB_ERR_INTERNAL:
20822  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20823  break;
20824  default:
20825  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
20826  break;
20827  }
20828 
20829 
20830  exit(rc);
20831  }
20832  #endif
20833 
20834 
20835  if(i == 1)
20836  {
20837  free_household_agent(current_xmachine_household_holder, household_HHHousingRevenue_state);
20838  }
20839  else
20840  {
20841  transition_household_agent(current_xmachine_household_holder, household_HHHousingRevenue_state, household_HHHousingPrice_state);
20842  }
20843 
20844 
20845  current_xmachine_household = NULL;
20846 
20847  current_xmachine_household_holder = temp_xmachine_household_holder;
20848  }
20849  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_collect_sale_revenue\n");
20850 
20851  if(FLAME_mortgage_payment_from_sale_message_board_write == 1)
20852  {
20853 
20854  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_payment_from_sale)\n");
20855  rc = MB_SyncStart(b_mortgage_payment_from_sale);
20856  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_payment_from_sale)\n");
20857  #ifdef ERRCHECK
20858  if (rc != MB_SUCCESS)
20859  {
20860  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_payment_from_sale' board\n");
20861  switch(rc) {
20862  case MB_ERR_INVALID:
20863  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is invalid\n");
20864  break;
20865  case MB_ERR_LOCKED:
20866  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is locked\n");
20867  break;
20868  case MB_ERR_MEMALLOC:
20869  fprintf(stderr, "\t reason: out of memory\n");
20870  break;
20871  case MB_ERR_INTERNAL:
20872  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20873  break;
20874  default:
20875  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
20876  break;
20877  }
20878 
20879 
20880  exit(rc);
20881  }
20882  #endif
20883  }
20884 
20885 
20886 
20887  /* If mb is not read then leave sync complete until last possible moment */
20888  if(FLAME_bought_housing_message_board_read == 1)
20889  {
20890  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bought_housing)\n");
20891  rc = MB_SyncComplete(b_bought_housing);
20892  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bought_housing)\n");
20893  #ifdef ERRCHECK
20894  if (rc != MB_SUCCESS)
20895  {
20896  fprintf(stderr, "ERROR: Could not complete sync of 'bought_housing' board\n");
20897  switch(rc) {
20898  case MB_ERR_INVALID:
20899  fprintf(stderr, "\t reason: 'bought_housing' board is invalid\n");
20900  break;
20901  case MB_ERR_MEMALLOC:
20902  fprintf(stderr, "\t reason: out of memory\n");
20903  break;
20904  case MB_ERR_INTERNAL:
20905  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20906  break;
20907  default:
20908  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
20909  break;
20910  }
20911 
20912 
20913  exit(rc);
20914  }
20915  #endif
20916 
20917 
20918 
20919  }
20920 
20921  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_buy\n");
20922  current_xmachine_household_holder = household_HHHousingBargain_state->agents;
20923  while(current_xmachine_household_holder)
20924  {
20925  temp_xmachine_household_holder = current_xmachine_household_holder->next;
20926  current_xmachine_household = current_xmachine_household_holder->agent;
20927  current_xmachine_household_next_state = household_HHHousingPrice_state;
20928  /* For backwards compatibility set current_xmachine */
20929  current_xmachine->xmachine_firm = NULL;
20930  current_xmachine->xmachine_household = NULL;
20931  current_xmachine->xmachine_equityfund = NULL;
20932  current_xmachine->xmachine_bank = NULL;
20933  current_xmachine->xmachine_government = NULL;
20934  current_xmachine->xmachine_centralbank = NULL;
20935  current_xmachine->xmachine_jpoffice = NULL;
20936  current_xmachine->xmachine_mall = NULL;
20937  current_xmachine->xmachine_reagency = NULL;
20938  current_xmachine->xmachine_household = current_xmachine_household;
20939 
20940 
20941 
20942 
20943 
20944 
20945 
20946 
20947  rc = MB_Iterator_CreateFiltered(b_bought_housing, &i_bought_housing, &FLAME_filter_household_household_housing_buy_HHHousingBargain_HHHousingPrice_bought_housing, current_xmachine_household);
20948 
20949 
20950 
20951  #ifdef ERRCHECK
20952  if (rc != MB_SUCCESS)
20953  {
20954  fprintf(stderr, "ERROR: Could not create Iterator for 'bought_housing'\n");
20955  switch(rc) {
20956  case MB_ERR_INVALID:
20957  fprintf(stderr, "\t reason: 'bought_housing' board is invalid\n");
20958  break;
20959  case MB_ERR_LOCKED:
20960  fprintf(stderr, "\t reason: 'bought_housing' board is locked\n");
20961  break;
20962  case MB_ERR_MEMALLOC:
20963  fprintf(stderr, "\t reason: out of memory\n");
20964  break;
20965  case MB_ERR_INTERNAL:
20966  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20967  break;
20968  default:
20969 
20970  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
20971 
20972 
20973  break;
20974  }
20975 
20976 
20977  exit(rc);
20978  }
20979  #endif
20980 
20981 
20982 
20983  i = household_housing_buy();
20984 
20985 
20986  rc = MB_Iterator_Delete(&i_bought_housing);
20987  #ifdef ERRCHECK
20988  if (rc != MB_SUCCESS)
20989  {
20990  fprintf(stderr, "ERROR: Could not delete 'bought_housing' iterator\n");
20991  switch(rc) {
20992  case MB_ERR_INVALID:
20993  fprintf(stderr, "\t reason: 'bought_housing' iterator is invalid\n");
20994  break;
20995  case MB_ERR_INTERNAL:
20996  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
20997  break;
20998  default:
20999  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
21000  break;
21001  }
21002 
21003 
21004  exit(rc);
21005  }
21006  #endif
21007 
21008 
21009  if(i == 1)
21010  {
21011  free_household_agent(current_xmachine_household_holder, household_HHHousingBargain_state);
21012  }
21013  else
21014  {
21015  transition_household_agent(current_xmachine_household_holder, household_HHHousingBargain_state, household_HHHousingPrice_state);
21016  }
21017 
21018 
21019  current_xmachine_household = NULL;
21020 
21021  current_xmachine_household_holder = temp_xmachine_household_holder;
21022  }
21023  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_buy\n");
21024 
21025 
21026  /* If mb is not read then leave sync complete until last possible moment */
21027  if(FLAME_mortgage_requests_message_board_read == 1)
21028  {
21029  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_requests)\n");
21030  rc = MB_SyncComplete(b_mortgage_requests);
21031  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_requests)\n");
21032  #ifdef ERRCHECK
21033  if (rc != MB_SUCCESS)
21034  {
21035  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_requests' board\n");
21036  switch(rc) {
21037  case MB_ERR_INVALID:
21038  fprintf(stderr, "\t reason: 'mortgage_requests' board is invalid\n");
21039  break;
21040  case MB_ERR_MEMALLOC:
21041  fprintf(stderr, "\t reason: out of memory\n");
21042  break;
21043  case MB_ERR_INTERNAL:
21044  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21045  break;
21046  default:
21047  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21048  break;
21049  }
21050 
21051 
21052  exit(rc);
21053  }
21054  #endif
21055 
21056 
21057 
21058  }
21059 
21060  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_housing_deliver_mortages\n");
21061  current_xmachine_bank_holder = bank_BankHousingCrediting_state->agents;
21062  while(current_xmachine_bank_holder)
21063  {
21064  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
21065  current_xmachine_bank = current_xmachine_bank_holder->agent;
21066  current_xmachine_bank_next_state = bank_BankHousingSales_state;
21067  /* For backwards compatibility set current_xmachine */
21068  current_xmachine->xmachine_firm = NULL;
21069  current_xmachine->xmachine_household = NULL;
21070  current_xmachine->xmachine_equityfund = NULL;
21071  current_xmachine->xmachine_bank = NULL;
21072  current_xmachine->xmachine_government = NULL;
21073  current_xmachine->xmachine_centralbank = NULL;
21074  current_xmachine->xmachine_jpoffice = NULL;
21075  current_xmachine->xmachine_mall = NULL;
21076  current_xmachine->xmachine_reagency = NULL;
21077  current_xmachine->xmachine_bank = current_xmachine_bank;
21078 
21079 
21080 
21081 
21082 
21083 
21084 
21085 
21086  rc = MB_Iterator_CreateFiltered(b_mortgage_requests, &i_mortgage_requests, &FLAME_filter_bank_bank_housing_deliver_mortages_BankHousingCrediting_BankHousingSales_mortgage_requests, current_xmachine_bank);
21087 
21088 
21089 
21090  #ifdef ERRCHECK
21091  if (rc != MB_SUCCESS)
21092  {
21093  fprintf(stderr, "ERROR: Could not create Iterator for 'mortgage_requests'\n");
21094  switch(rc) {
21095  case MB_ERR_INVALID:
21096  fprintf(stderr, "\t reason: 'mortgage_requests' board is invalid\n");
21097  break;
21098  case MB_ERR_LOCKED:
21099  fprintf(stderr, "\t reason: 'mortgage_requests' board is locked\n");
21100  break;
21101  case MB_ERR_MEMALLOC:
21102  fprintf(stderr, "\t reason: out of memory\n");
21103  break;
21104  case MB_ERR_INTERNAL:
21105  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21106  break;
21107  default:
21108 
21109  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
21110 
21111 
21112  break;
21113  }
21114 
21115 
21116  exit(rc);
21117  }
21118  #endif
21119 
21120 
21121 
21122  i = bank_housing_deliver_mortages();
21123 
21124 
21125  rc = MB_Iterator_Delete(&i_mortgage_requests);
21126  #ifdef ERRCHECK
21127  if (rc != MB_SUCCESS)
21128  {
21129  fprintf(stderr, "ERROR: Could not delete 'mortgage_requests' iterator\n");
21130  switch(rc) {
21131  case MB_ERR_INVALID:
21132  fprintf(stderr, "\t reason: 'mortgage_requests' iterator is invalid\n");
21133  break;
21134  case MB_ERR_INTERNAL:
21135  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21136  break;
21137  default:
21138  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
21139  break;
21140  }
21141 
21142 
21143  exit(rc);
21144  }
21145  #endif
21146 
21147 
21148  if(i == 1)
21149  {
21150  free_bank_agent(current_xmachine_bank_holder, bank_BankHousingCrediting_state);
21151  }
21152  else
21153  {
21154  transition_bank_agent(current_xmachine_bank_holder, bank_BankHousingCrediting_state, bank_BankHousingSales_state);
21155  }
21156 
21157 
21158  current_xmachine_bank = NULL;
21159 
21160  current_xmachine_bank_holder = temp_xmachine_bank_holder;
21161  }
21162  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_housing_deliver_mortages\n");
21163 
21164 
21165 /* End of layer number 46 */
21166 
21167 /* Clear message boards that have finished being used
21168  * and sync complete if doing late sync complete */
21169 
21170 if(FLAME_bought_housing_message_board_read == 0)
21171 {
21172  /*printf("%d> bought_housing message board sync complete late as no agents reading any messages of this type\n", node_number);*/
21173 
21174  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_bought_housing)\n");
21175  rc = MB_SyncComplete(b_bought_housing);
21176  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_bought_housing)\n");
21177  #ifdef ERRCHECK
21178  if (rc != MB_SUCCESS)
21179  {
21180  fprintf(stderr, "ERROR: Could not complete sync of 'bought_housing' board\n");
21181  switch(rc) {
21182  case MB_ERR_INVALID:
21183  fprintf(stderr, "\t reason: 'bought_housing' board is invalid\n");
21184  break;
21185  case MB_ERR_MEMALLOC:
21186  fprintf(stderr, "\t reason: out of memory\n");
21187  break;
21188  case MB_ERR_INTERNAL:
21189  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21190  break;
21191  default:
21192  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21193  break;
21194  }
21195 
21196 
21197  exit(rc);
21198  }
21199  #endif
21200 }
21201 
21202  /* Delete any search trees */
21203 
21204  rc = MB_Clear(b_bought_housing);
21205  #ifdef ERRCHECK
21206  if (rc != MB_SUCCESS)
21207  {
21208  fprintf(stderr, "ERROR: Could not clear 'bought_housing' board\n");
21209  switch(rc) {
21210  case MB_ERR_INVALID:
21211  fprintf(stderr, "\t reason: 'bought_housing' board is invalid\n");
21212  break;
21213  case MB_ERR_LOCKED:
21214  fprintf(stderr, "\t reason: 'bought_housing' board is locked\n");
21215  break;
21216  case MB_ERR_INTERNAL:
21217  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21218  break;
21219  default:
21220  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
21221  break;
21222 
21223  }
21224 
21225 
21226  exit(rc);
21227  }
21228  #endif
21229 
21230 if(FLAME_sold_housing_message_board_read == 0)
21231 {
21232  /*printf("%d> sold_housing message board sync complete late as no agents reading any messages of this type\n", node_number);*/
21233 
21234  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_sold_housing)\n");
21235  rc = MB_SyncComplete(b_sold_housing);
21236  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_sold_housing)\n");
21237  #ifdef ERRCHECK
21238  if (rc != MB_SUCCESS)
21239  {
21240  fprintf(stderr, "ERROR: Could not complete sync of 'sold_housing' board\n");
21241  switch(rc) {
21242  case MB_ERR_INVALID:
21243  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
21244  break;
21245  case MB_ERR_MEMALLOC:
21246  fprintf(stderr, "\t reason: out of memory\n");
21247  break;
21248  case MB_ERR_INTERNAL:
21249  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21250  break;
21251  default:
21252  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21253  break;
21254  }
21255 
21256 
21257  exit(rc);
21258  }
21259  #endif
21260 }
21261 
21262  /* Delete any search trees */
21263 
21264  rc = MB_Clear(b_sold_housing);
21265  #ifdef ERRCHECK
21266  if (rc != MB_SUCCESS)
21267  {
21268  fprintf(stderr, "ERROR: Could not clear 'sold_housing' board\n");
21269  switch(rc) {
21270  case MB_ERR_INVALID:
21271  fprintf(stderr, "\t reason: 'sold_housing' board is invalid\n");
21272  break;
21273  case MB_ERR_LOCKED:
21274  fprintf(stderr, "\t reason: 'sold_housing' board is locked\n");
21275  break;
21276  case MB_ERR_INTERNAL:
21277  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21278  break;
21279  default:
21280  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
21281  break;
21282 
21283  }
21284 
21285 
21286  exit(rc);
21287  }
21288  #endif
21289 
21290 if(FLAME_mortgage_requests_message_board_read == 0)
21291 {
21292  /*printf("%d> mortgage_requests message board sync complete late as no agents reading any messages of this type\n", node_number);*/
21293 
21294  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_requests)\n");
21295  rc = MB_SyncComplete(b_mortgage_requests);
21296  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_requests)\n");
21297  #ifdef ERRCHECK
21298  if (rc != MB_SUCCESS)
21299  {
21300  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_requests' board\n");
21301  switch(rc) {
21302  case MB_ERR_INVALID:
21303  fprintf(stderr, "\t reason: 'mortgage_requests' board is invalid\n");
21304  break;
21305  case MB_ERR_MEMALLOC:
21306  fprintf(stderr, "\t reason: out of memory\n");
21307  break;
21308  case MB_ERR_INTERNAL:
21309  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21310  break;
21311  default:
21312  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21313  break;
21314  }
21315 
21316 
21317  exit(rc);
21318  }
21319  #endif
21320 }
21321 
21322  /* Delete any search trees */
21323 
21324  rc = MB_Clear(b_mortgage_requests);
21325  #ifdef ERRCHECK
21326  if (rc != MB_SUCCESS)
21327  {
21328  fprintf(stderr, "ERROR: Could not clear 'mortgage_requests' board\n");
21329  switch(rc) {
21330  case MB_ERR_INVALID:
21331  fprintf(stderr, "\t reason: 'mortgage_requests' board is invalid\n");
21332  break;
21333  case MB_ERR_LOCKED:
21334  fprintf(stderr, "\t reason: 'mortgage_requests' board is locked\n");
21335  break;
21336  case MB_ERR_INTERNAL:
21337  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21338  break;
21339  default:
21340  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
21341  break;
21342 
21343  }
21344 
21345 
21346  exit(rc);
21347  }
21348  #endif
21349 
21350 
21351  /* If mb is not read then leave sync complete until last possible moment */
21352  if(FLAME_housing_price_message_board_read == 1)
21353  {
21354  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_housing_price)\n");
21355  rc = MB_SyncComplete(b_housing_price);
21356  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_housing_price)\n");
21357  #ifdef ERRCHECK
21358  if (rc != MB_SUCCESS)
21359  {
21360  fprintf(stderr, "ERROR: Could not complete sync of 'housing_price' board\n");
21361  switch(rc) {
21362  case MB_ERR_INVALID:
21363  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
21364  break;
21365  case MB_ERR_MEMALLOC:
21366  fprintf(stderr, "\t reason: out of memory\n");
21367  break;
21368  case MB_ERR_INTERNAL:
21369  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21370  break;
21371  default:
21372  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21373  break;
21374  }
21375 
21376 
21377  exit(rc);
21378  }
21379  #endif
21380 
21381 
21382 
21383  }
21384 
21385  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_housing_update_market_price\n");
21386  current_xmachine_firm_holder = firm_FirmHousingPrice_state->agents;
21387  while(current_xmachine_firm_holder)
21388  {
21389  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
21390  current_xmachine_firm = current_xmachine_firm_holder->agent;
21391  current_xmachine_firm_next_state = firm_FirmUpdateDeposits_state;
21392  /* For backwards compatibility set current_xmachine */
21393  current_xmachine->xmachine_firm = NULL;
21394  current_xmachine->xmachine_household = NULL;
21395  current_xmachine->xmachine_equityfund = NULL;
21396  current_xmachine->xmachine_bank = NULL;
21397  current_xmachine->xmachine_government = NULL;
21398  current_xmachine->xmachine_centralbank = NULL;
21399  current_xmachine->xmachine_jpoffice = NULL;
21400  current_xmachine->xmachine_mall = NULL;
21401  current_xmachine->xmachine_reagency = NULL;
21402  current_xmachine->xmachine_firm = current_xmachine_firm;
21403 
21404 
21405 
21406 
21407 
21408 
21409  rc = MB_Iterator_Create(b_housing_price, &i_housing_price);
21410 
21411 
21412  #ifdef ERRCHECK
21413  if (rc != MB_SUCCESS)
21414  {
21415  fprintf(stderr, "ERROR: Could not create Iterator for 'housing_price'\n");
21416  switch(rc) {
21417  case MB_ERR_INVALID:
21418  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
21419  break;
21420  case MB_ERR_LOCKED:
21421  fprintf(stderr, "\t reason: 'housing_price' board is locked\n");
21422  break;
21423  case MB_ERR_MEMALLOC:
21424  fprintf(stderr, "\t reason: out of memory\n");
21425  break;
21426  case MB_ERR_INTERNAL:
21427  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21428  break;
21429  default:
21430 
21431 
21432  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
21433 
21434  break;
21435  }
21436 
21437 
21438  exit(rc);
21439  }
21440  #endif
21441 
21442 
21443 
21444  i = firm_housing_update_market_price();
21445 
21446 
21447  rc = MB_Iterator_Delete(&i_housing_price);
21448  #ifdef ERRCHECK
21449  if (rc != MB_SUCCESS)
21450  {
21451  fprintf(stderr, "ERROR: Could not delete 'housing_price' iterator\n");
21452  switch(rc) {
21453  case MB_ERR_INVALID:
21454  fprintf(stderr, "\t reason: 'housing_price' iterator is invalid\n");
21455  break;
21456  case MB_ERR_INTERNAL:
21457  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21458  break;
21459  default:
21460  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
21461  break;
21462  }
21463 
21464 
21465  exit(rc);
21466  }
21467  #endif
21468 
21469 
21470  if(i == 1)
21471  {
21472  free_firm_agent(current_xmachine_firm_holder, firm_FirmHousingPrice_state);
21473  }
21474  else
21475  {
21476  transition_firm_agent(current_xmachine_firm_holder, firm_FirmHousingPrice_state, firm_FirmUpdateDeposits_state);
21477  }
21478 
21479 
21480  current_xmachine_firm = NULL;
21481 
21482  current_xmachine_firm_holder = temp_xmachine_firm_holder;
21483  }
21484  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_housing_update_market_price\n");
21485 
21486 
21487  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_update_market_price\n");
21488  current_xmachine_household_holder = household_HHHousingPrice_state->agents;
21489  while(current_xmachine_household_holder)
21490  {
21491  temp_xmachine_household_holder = current_xmachine_household_holder->next;
21492  current_xmachine_household = current_xmachine_household_holder->agent;
21493  current_xmachine_household_next_state = household_HHHousingPayments_state;
21494  /* For backwards compatibility set current_xmachine */
21495  current_xmachine->xmachine_firm = NULL;
21496  current_xmachine->xmachine_household = NULL;
21497  current_xmachine->xmachine_equityfund = NULL;
21498  current_xmachine->xmachine_bank = NULL;
21499  current_xmachine->xmachine_government = NULL;
21500  current_xmachine->xmachine_centralbank = NULL;
21501  current_xmachine->xmachine_jpoffice = NULL;
21502  current_xmachine->xmachine_mall = NULL;
21503  current_xmachine->xmachine_reagency = NULL;
21504  current_xmachine->xmachine_household = current_xmachine_household;
21505 
21506 
21507 
21508 
21509 
21510 
21511  rc = MB_Iterator_Create(b_housing_price, &i_housing_price);
21512 
21513 
21514  #ifdef ERRCHECK
21515  if (rc != MB_SUCCESS)
21516  {
21517  fprintf(stderr, "ERROR: Could not create Iterator for 'housing_price'\n");
21518  switch(rc) {
21519  case MB_ERR_INVALID:
21520  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
21521  break;
21522  case MB_ERR_LOCKED:
21523  fprintf(stderr, "\t reason: 'housing_price' board is locked\n");
21524  break;
21525  case MB_ERR_MEMALLOC:
21526  fprintf(stderr, "\t reason: out of memory\n");
21527  break;
21528  case MB_ERR_INTERNAL:
21529  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21530  break;
21531  default:
21532 
21533 
21534  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
21535 
21536  break;
21537  }
21538 
21539 
21540  exit(rc);
21541  }
21542  #endif
21543 
21544 
21545 
21546  i = household_housing_update_market_price();
21547 
21548 
21549  rc = MB_Iterator_Delete(&i_housing_price);
21550  #ifdef ERRCHECK
21551  if (rc != MB_SUCCESS)
21552  {
21553  fprintf(stderr, "ERROR: Could not delete 'housing_price' iterator\n");
21554  switch(rc) {
21555  case MB_ERR_INVALID:
21556  fprintf(stderr, "\t reason: 'housing_price' iterator is invalid\n");
21557  break;
21558  case MB_ERR_INTERNAL:
21559  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21560  break;
21561  default:
21562  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
21563  break;
21564  }
21565 
21566 
21567  exit(rc);
21568  }
21569  #endif
21570 
21571 
21572  if(i == 1)
21573  {
21574  free_household_agent(current_xmachine_household_holder, household_HHHousingPrice_state);
21575  }
21576  else
21577  {
21578  transition_household_agent(current_xmachine_household_holder, household_HHHousingPrice_state, household_HHHousingPayments_state);
21579  }
21580 
21581 
21582  current_xmachine_household = NULL;
21583 
21584  current_xmachine_household_holder = temp_xmachine_household_holder;
21585  }
21586  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_update_market_price\n");
21587 
21588 
21589  /* If mb is not read then leave sync complete until last possible moment */
21590  if(FLAME_housing_transactions_summary_message_board_read == 1)
21591  {
21592  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_housing_transactions_summary)\n");
21593  rc = MB_SyncComplete(b_housing_transactions_summary);
21594  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_housing_transactions_summary)\n");
21595  #ifdef ERRCHECK
21596  if (rc != MB_SUCCESS)
21597  {
21598  fprintf(stderr, "ERROR: Could not complete sync of 'housing_transactions_summary' board\n");
21599  switch(rc) {
21600  case MB_ERR_INVALID:
21601  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is invalid\n");
21602  break;
21603  case MB_ERR_MEMALLOC:
21604  fprintf(stderr, "\t reason: out of memory\n");
21605  break;
21606  case MB_ERR_INTERNAL:
21607  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21608  break;
21609  default:
21610  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21611  break;
21612  }
21613 
21614 
21615  exit(rc);
21616  }
21617  #endif
21618 
21619 
21620 
21621  }
21622 
21623  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start centralbank_trace_housing_prices\n");
21624  current_xmachine_centralbank_holder = centralbank_CentralBankHousing_state->agents;
21625  while(current_xmachine_centralbank_holder)
21626  {
21627  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
21628  current_xmachine_centralbank = current_xmachine_centralbank_holder->agent;
21629  current_xmachine_centralbank_next_state = centralbank_end_state;
21630  /* For backwards compatibility set current_xmachine */
21631  current_xmachine->xmachine_firm = NULL;
21632  current_xmachine->xmachine_household = NULL;
21633  current_xmachine->xmachine_equityfund = NULL;
21634  current_xmachine->xmachine_bank = NULL;
21635  current_xmachine->xmachine_government = NULL;
21636  current_xmachine->xmachine_centralbank = NULL;
21637  current_xmachine->xmachine_jpoffice = NULL;
21638  current_xmachine->xmachine_mall = NULL;
21639  current_xmachine->xmachine_reagency = NULL;
21640  current_xmachine->xmachine_centralbank = current_xmachine_centralbank;
21641 
21642  if(FLAME_condition_centralbank_centralbank_trace_housing_prices_CentralBankHousing_end(current_xmachine_centralbank)==1)
21643  {
21644 
21645 
21646 
21647 
21648  rc = MB_Iterator_Create(b_housing_transactions_summary, &i_housing_transactions_summary);
21649 
21650 
21651  #ifdef ERRCHECK
21652  if (rc != MB_SUCCESS)
21653  {
21654  fprintf(stderr, "ERROR: Could not create Iterator for 'housing_transactions_summary'\n");
21655  switch(rc) {
21656  case MB_ERR_INVALID:
21657  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is invalid\n");
21658  break;
21659  case MB_ERR_LOCKED:
21660  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is locked\n");
21661  break;
21662  case MB_ERR_MEMALLOC:
21663  fprintf(stderr, "\t reason: out of memory\n");
21664  break;
21665  case MB_ERR_INTERNAL:
21666  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21667  break;
21668  default:
21669 
21670 
21671  fprintf(stderr, "\t MB_Iterator_Create returned error code: %d (see libmboard docs for details)\n", rc);
21672 
21673  break;
21674  }
21675 
21676 
21677  exit(rc);
21678  }
21679  #endif
21680 
21681 
21682 
21683  i = centralbank_trace_housing_prices();
21684 
21685 
21686  rc = MB_Iterator_Delete(&i_housing_transactions_summary);
21687  #ifdef ERRCHECK
21688  if (rc != MB_SUCCESS)
21689  {
21690  fprintf(stderr, "ERROR: Could not delete 'housing_transactions_summary' iterator\n");
21691  switch(rc) {
21692  case MB_ERR_INVALID:
21693  fprintf(stderr, "\t reason: 'housing_transactions_summary' iterator is invalid\n");
21694  break;
21695  case MB_ERR_INTERNAL:
21696  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21697  break;
21698  default:
21699  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
21700  break;
21701  }
21702 
21703 
21704  exit(rc);
21705  }
21706  #endif
21707 
21708 
21709  if(i == 1)
21710  {
21711  free_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankHousing_state);
21712  }
21713  else
21714  {
21715  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_CentralBankHousing_state, centralbank_end_state);
21716  }
21717  }
21718 
21719  current_xmachine_centralbank = NULL;
21720 
21721  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
21722  }
21723  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish centralbank_trace_housing_prices\n");
21724 
21725 
21726  /* If mb is not read then leave sync complete until last possible moment */
21727  if(FLAME_mortgage_payment_from_sale_message_board_read == 1)
21728  {
21729  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_payment_from_sale)\n");
21730  rc = MB_SyncComplete(b_mortgage_payment_from_sale);
21731  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_payment_from_sale)\n");
21732  #ifdef ERRCHECK
21733  if (rc != MB_SUCCESS)
21734  {
21735  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_payment_from_sale' board\n");
21736  switch(rc) {
21737  case MB_ERR_INVALID:
21738  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is invalid\n");
21739  break;
21740  case MB_ERR_MEMALLOC:
21741  fprintf(stderr, "\t reason: out of memory\n");
21742  break;
21743  case MB_ERR_INTERNAL:
21744  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21745  break;
21746  default:
21747  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21748  break;
21749  }
21750 
21751 
21752  exit(rc);
21753  }
21754  #endif
21755 
21756 
21757 
21758  }
21759 
21760  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_housing_recieve_mortgage_principals\n");
21761  current_xmachine_bank_holder = bank_BankHousingSales_state->agents;
21762  while(current_xmachine_bank_holder)
21763  {
21764  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
21765  current_xmachine_bank = current_xmachine_bank_holder->agent;
21766  current_xmachine_bank_next_state = bank_BankHousingMortgages_state;
21767  /* For backwards compatibility set current_xmachine */
21768  current_xmachine->xmachine_firm = NULL;
21769  current_xmachine->xmachine_household = NULL;
21770  current_xmachine->xmachine_equityfund = NULL;
21771  current_xmachine->xmachine_bank = NULL;
21772  current_xmachine->xmachine_government = NULL;
21773  current_xmachine->xmachine_centralbank = NULL;
21774  current_xmachine->xmachine_jpoffice = NULL;
21775  current_xmachine->xmachine_mall = NULL;
21776  current_xmachine->xmachine_reagency = NULL;
21777  current_xmachine->xmachine_bank = current_xmachine_bank;
21778 
21779 
21780 
21781 
21782 
21783 
21784 
21785 
21786  rc = MB_Iterator_CreateFiltered(b_mortgage_payment_from_sale, &i_mortgage_payment_from_sale, &FLAME_filter_bank_bank_housing_recieve_mortgage_principals_BankHousingSales_BankHousingMortgages_mortgage_payment_from_sale, current_xmachine_bank);
21787 
21788 
21789 
21790  #ifdef ERRCHECK
21791  if (rc != MB_SUCCESS)
21792  {
21793  fprintf(stderr, "ERROR: Could not create Iterator for 'mortgage_payment_from_sale'\n");
21794  switch(rc) {
21795  case MB_ERR_INVALID:
21796  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is invalid\n");
21797  break;
21798  case MB_ERR_LOCKED:
21799  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is locked\n");
21800  break;
21801  case MB_ERR_MEMALLOC:
21802  fprintf(stderr, "\t reason: out of memory\n");
21803  break;
21804  case MB_ERR_INTERNAL:
21805  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21806  break;
21807  default:
21808 
21809  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
21810 
21811 
21812  break;
21813  }
21814 
21815 
21816  exit(rc);
21817  }
21818  #endif
21819 
21820 
21821 
21822  i = bank_housing_recieve_mortgage_principals();
21823 
21824 
21825  rc = MB_Iterator_Delete(&i_mortgage_payment_from_sale);
21826  #ifdef ERRCHECK
21827  if (rc != MB_SUCCESS)
21828  {
21829  fprintf(stderr, "ERROR: Could not delete 'mortgage_payment_from_sale' iterator\n");
21830  switch(rc) {
21831  case MB_ERR_INVALID:
21832  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' iterator is invalid\n");
21833  break;
21834  case MB_ERR_INTERNAL:
21835  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21836  break;
21837  default:
21838  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
21839  break;
21840  }
21841 
21842 
21843  exit(rc);
21844  }
21845  #endif
21846 
21847 
21848  if(i == 1)
21849  {
21850  free_bank_agent(current_xmachine_bank_holder, bank_BankHousingSales_state);
21851  }
21852  else
21853  {
21854  transition_bank_agent(current_xmachine_bank_holder, bank_BankHousingSales_state, bank_BankHousingMortgages_state);
21855  }
21856 
21857 
21858  current_xmachine_bank = NULL;
21859 
21860  current_xmachine_bank_holder = temp_xmachine_bank_holder;
21861  }
21862  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_housing_recieve_mortgage_principals\n");
21863 
21864 
21865 /* End of layer number 47 */
21866 
21867 /* Clear message boards that have finished being used
21868  * and sync complete if doing late sync complete */
21869 
21870 if(FLAME_housing_price_message_board_read == 0)
21871 {
21872  /*printf("%d> housing_price message board sync complete late as no agents reading any messages of this type\n", node_number);*/
21873 
21874  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_housing_price)\n");
21875  rc = MB_SyncComplete(b_housing_price);
21876  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_housing_price)\n");
21877  #ifdef ERRCHECK
21878  if (rc != MB_SUCCESS)
21879  {
21880  fprintf(stderr, "ERROR: Could not complete sync of 'housing_price' board\n");
21881  switch(rc) {
21882  case MB_ERR_INVALID:
21883  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
21884  break;
21885  case MB_ERR_MEMALLOC:
21886  fprintf(stderr, "\t reason: out of memory\n");
21887  break;
21888  case MB_ERR_INTERNAL:
21889  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21890  break;
21891  default:
21892  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21893  break;
21894  }
21895 
21896 
21897  exit(rc);
21898  }
21899  #endif
21900 }
21901 
21902  /* Delete any search trees */
21903 
21904  rc = MB_Clear(b_housing_price);
21905  #ifdef ERRCHECK
21906  if (rc != MB_SUCCESS)
21907  {
21908  fprintf(stderr, "ERROR: Could not clear 'housing_price' board\n");
21909  switch(rc) {
21910  case MB_ERR_INVALID:
21911  fprintf(stderr, "\t reason: 'housing_price' board is invalid\n");
21912  break;
21913  case MB_ERR_LOCKED:
21914  fprintf(stderr, "\t reason: 'housing_price' board is locked\n");
21915  break;
21916  case MB_ERR_INTERNAL:
21917  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21918  break;
21919  default:
21920  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
21921  break;
21922 
21923  }
21924 
21925 
21926  exit(rc);
21927  }
21928  #endif
21929 
21930 if(FLAME_mortgage_payment_from_sale_message_board_read == 0)
21931 {
21932  /*printf("%d> mortgage_payment_from_sale message board sync complete late as no agents reading any messages of this type\n", node_number);*/
21933 
21934  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_payment_from_sale)\n");
21935  rc = MB_SyncComplete(b_mortgage_payment_from_sale);
21936  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_payment_from_sale)\n");
21937  #ifdef ERRCHECK
21938  if (rc != MB_SUCCESS)
21939  {
21940  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_payment_from_sale' board\n");
21941  switch(rc) {
21942  case MB_ERR_INVALID:
21943  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is invalid\n");
21944  break;
21945  case MB_ERR_MEMALLOC:
21946  fprintf(stderr, "\t reason: out of memory\n");
21947  break;
21948  case MB_ERR_INTERNAL:
21949  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21950  break;
21951  default:
21952  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
21953  break;
21954  }
21955 
21956 
21957  exit(rc);
21958  }
21959  #endif
21960 }
21961 
21962  /* Delete any search trees */
21963 
21964  rc = MB_Clear(b_mortgage_payment_from_sale);
21965  #ifdef ERRCHECK
21966  if (rc != MB_SUCCESS)
21967  {
21968  fprintf(stderr, "ERROR: Could not clear 'mortgage_payment_from_sale' board\n");
21969  switch(rc) {
21970  case MB_ERR_INVALID:
21971  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is invalid\n");
21972  break;
21973  case MB_ERR_LOCKED:
21974  fprintf(stderr, "\t reason: 'mortgage_payment_from_sale' board is locked\n");
21975  break;
21976  case MB_ERR_INTERNAL:
21977  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
21978  break;
21979  default:
21980  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
21981  break;
21982 
21983  }
21984 
21985 
21986  exit(rc);
21987  }
21988  #endif
21989 
21990 if(FLAME_housing_transactions_summary_message_board_read == 0)
21991 {
21992  /*printf("%d> housing_transactions_summary message board sync complete late as no agents reading any messages of this type\n", node_number);*/
21993 
21994  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_housing_transactions_summary)\n");
21995  rc = MB_SyncComplete(b_housing_transactions_summary);
21996  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_housing_transactions_summary)\n");
21997  #ifdef ERRCHECK
21998  if (rc != MB_SUCCESS)
21999  {
22000  fprintf(stderr, "ERROR: Could not complete sync of 'housing_transactions_summary' board\n");
22001  switch(rc) {
22002  case MB_ERR_INVALID:
22003  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is invalid\n");
22004  break;
22005  case MB_ERR_MEMALLOC:
22006  fprintf(stderr, "\t reason: out of memory\n");
22007  break;
22008  case MB_ERR_INTERNAL:
22009  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22010  break;
22011  default:
22012  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
22013  break;
22014  }
22015 
22016 
22017  exit(rc);
22018  }
22019  #endif
22020 }
22021 
22022  /* Delete any search trees */
22023 
22024  rc = MB_Clear(b_housing_transactions_summary);
22025  #ifdef ERRCHECK
22026  if (rc != MB_SUCCESS)
22027  {
22028  fprintf(stderr, "ERROR: Could not clear 'housing_transactions_summary' board\n");
22029  switch(rc) {
22030  case MB_ERR_INVALID:
22031  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is invalid\n");
22032  break;
22033  case MB_ERR_LOCKED:
22034  fprintf(stderr, "\t reason: 'housing_transactions_summary' board is locked\n");
22035  break;
22036  case MB_ERR_INTERNAL:
22037  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22038  break;
22039  default:
22040  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
22041  break;
22042 
22043  }
22044 
22045 
22046  exit(rc);
22047  }
22048  #endif
22049 
22050  /* DEBUG: States with branching functions */
22051  current_xmachine_firm_holder = firm_FirmUpdateDeposits_state->agents;
22052  while(current_xmachine_firm_holder)
22053  {
22054  FLAME_debug_count = 0;
22055  /* Function: firm_update_bank_account */
22056  if(FLAME_condition_firm_firm_update_bank_account_FirmUpdateDeposits_end(current_xmachine_firm_holder->agent)==1)
22057  { FLAME_debug_count++; }
22058  /* Function: idle */
22059  if(FLAME_condition_firm_idle_FirmUpdateDeposits_end(current_xmachine_firm_holder->agent)==1)
22060  { FLAME_debug_count++; }
22061  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
22062  if(FLAME_debug_count != 1)
22063  {
22064  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'firm' leaving state 'FirmUpdateDeposits'\n");
22065  if(FLAME_debug_count > 1)
22066  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
22067  if(FLAME_debug_count == 0)
22068  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
22069  }
22070 
22071  current_xmachine_firm_holder = current_xmachine_firm_holder->next;
22072  }
22073 
22074  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_pay_mortgages\n");
22075  current_xmachine_household_holder = household_HHHousingPayments_state->agents;
22076  while(current_xmachine_household_holder)
22077  {
22078  temp_xmachine_household_holder = current_xmachine_household_holder->next;
22079  current_xmachine_household = current_xmachine_household_holder->agent;
22080  current_xmachine_household_next_state = household_HHHousingWriteOff_state;
22081  /* For backwards compatibility set current_xmachine */
22082  current_xmachine->xmachine_firm = NULL;
22083  current_xmachine->xmachine_household = NULL;
22084  current_xmachine->xmachine_equityfund = NULL;
22085  current_xmachine->xmachine_bank = NULL;
22086  current_xmachine->xmachine_government = NULL;
22087  current_xmachine->xmachine_centralbank = NULL;
22088  current_xmachine->xmachine_jpoffice = NULL;
22089  current_xmachine->xmachine_mall = NULL;
22090  current_xmachine->xmachine_reagency = NULL;
22091  current_xmachine->xmachine_household = current_xmachine_household;
22092 
22093 
22094 
22095 
22096 
22097  i = household_housing_pay_mortgages();
22098 
22099 
22100 
22101  if(i == 1)
22102  {
22103  free_household_agent(current_xmachine_household_holder, household_HHHousingPayments_state);
22104  }
22105  else
22106  {
22107  transition_household_agent(current_xmachine_household_holder, household_HHHousingPayments_state, household_HHHousingWriteOff_state);
22108  }
22109 
22110 
22111  current_xmachine_household = NULL;
22112 
22113  current_xmachine_household_holder = temp_xmachine_household_holder;
22114  }
22115  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_pay_mortgages\n");
22116 
22117  if(FLAME_mortgage_payment_message_board_write == 1)
22118  {
22119 
22120  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_payment)\n");
22121  rc = MB_SyncStart(b_mortgage_payment);
22122  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_payment)\n");
22123  #ifdef ERRCHECK
22124  if (rc != MB_SUCCESS)
22125  {
22126  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_payment' board\n");
22127  switch(rc) {
22128  case MB_ERR_INVALID:
22129  fprintf(stderr, "\t reason: 'mortgage_payment' board is invalid\n");
22130  break;
22131  case MB_ERR_LOCKED:
22132  fprintf(stderr, "\t reason: 'mortgage_payment' board is locked\n");
22133  break;
22134  case MB_ERR_MEMALLOC:
22135  fprintf(stderr, "\t reason: out of memory\n");
22136  break;
22137  case MB_ERR_INTERNAL:
22138  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22139  break;
22140  default:
22141  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
22142  break;
22143  }
22144 
22145 
22146  exit(rc);
22147  }
22148  #endif
22149  }
22150 
22151 
22152 
22153  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start firm_update_bank_account\n");
22154  current_xmachine_firm_holder = firm_FirmUpdateDeposits_state->agents;
22155  while(current_xmachine_firm_holder)
22156  {
22157  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
22158  current_xmachine_firm = current_xmachine_firm_holder->agent;
22159  current_xmachine_firm_next_state = firm_end_state;
22160  /* For backwards compatibility set current_xmachine */
22161  current_xmachine->xmachine_firm = NULL;
22162  current_xmachine->xmachine_household = NULL;
22163  current_xmachine->xmachine_equityfund = NULL;
22164  current_xmachine->xmachine_bank = NULL;
22165  current_xmachine->xmachine_government = NULL;
22166  current_xmachine->xmachine_centralbank = NULL;
22167  current_xmachine->xmachine_jpoffice = NULL;
22168  current_xmachine->xmachine_mall = NULL;
22169  current_xmachine->xmachine_reagency = NULL;
22170  current_xmachine->xmachine_firm = current_xmachine_firm;
22171 
22172  if(FLAME_condition_firm_firm_update_bank_account_FirmUpdateDeposits_end(current_xmachine_firm)==1)
22173  {
22174 
22175 
22176 
22177  i = firm_update_bank_account();
22178 
22179 
22180 
22181  if(i == 1)
22182  {
22183  free_firm_agent(current_xmachine_firm_holder, firm_FirmUpdateDeposits_state);
22184  }
22185  else
22186  {
22187  transition_firm_agent(current_xmachine_firm_holder, firm_FirmUpdateDeposits_state, firm_end_state);
22188  }
22189  }
22190 
22191  current_xmachine_firm = NULL;
22192 
22193  current_xmachine_firm_holder = temp_xmachine_firm_holder;
22194  }
22195  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish firm_update_bank_account\n");
22196 
22197  if(FLAME_firm_bank_update_deposit_message_board_write == 1)
22198  {
22199 
22200  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_firm_bank_update_deposit)\n");
22201  rc = MB_SyncStart(b_firm_bank_update_deposit);
22202  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_firm_bank_update_deposit)\n");
22203  #ifdef ERRCHECK
22204  if (rc != MB_SUCCESS)
22205  {
22206  fprintf(stderr, "ERROR: Could not start sync of 'firm_bank_update_deposit' board\n");
22207  switch(rc) {
22208  case MB_ERR_INVALID:
22209  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is invalid\n");
22210  break;
22211  case MB_ERR_LOCKED:
22212  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is locked\n");
22213  break;
22214  case MB_ERR_MEMALLOC:
22215  fprintf(stderr, "\t reason: out of memory\n");
22216  break;
22217  case MB_ERR_INTERNAL:
22218  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22219  break;
22220  default:
22221  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
22222  break;
22223  }
22224 
22225 
22226  exit(rc);
22227  }
22228  #endif
22229  }
22230 
22231 
22232 
22233  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
22234  current_xmachine_firm_holder = firm_FirmUpdateDeposits_state->agents;
22235  while(current_xmachine_firm_holder)
22236  {
22237  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
22238  current_xmachine_firm = current_xmachine_firm_holder->agent;
22239  current_xmachine_firm_next_state = firm_end_state;
22240  /* For backwards compatibility set current_xmachine */
22241  current_xmachine->xmachine_firm = NULL;
22242  current_xmachine->xmachine_household = NULL;
22243  current_xmachine->xmachine_equityfund = NULL;
22244  current_xmachine->xmachine_bank = NULL;
22245  current_xmachine->xmachine_government = NULL;
22246  current_xmachine->xmachine_centralbank = NULL;
22247  current_xmachine->xmachine_jpoffice = NULL;
22248  current_xmachine->xmachine_mall = NULL;
22249  current_xmachine->xmachine_reagency = NULL;
22250  current_xmachine->xmachine_firm = current_xmachine_firm;
22251 
22252  if(FLAME_condition_firm_idle_FirmUpdateDeposits_end(current_xmachine_firm)==1)
22253  {
22254 
22255 
22256 
22257  i = idle();
22258 
22259 
22260 
22261  if(i == 1)
22262  {
22263  free_firm_agent(current_xmachine_firm_holder, firm_FirmUpdateDeposits_state);
22264  }
22265  else
22266  {
22267  transition_firm_agent(current_xmachine_firm_holder, firm_FirmUpdateDeposits_state, firm_end_state);
22268  }
22269  }
22270 
22271  current_xmachine_firm = NULL;
22272 
22273  current_xmachine_firm_holder = temp_xmachine_firm_holder;
22274  }
22275  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
22276 
22277 
22278 /* End of layer number 48 */
22279 
22280 /* Clear message boards that have finished being used
22281  * and sync complete if doing late sync complete */
22282 
22283 
22284  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_housing_debt_writeoff\n");
22285  current_xmachine_household_holder = household_HHHousingWriteOff_state->agents;
22286  while(current_xmachine_household_holder)
22287  {
22288  temp_xmachine_household_holder = current_xmachine_household_holder->next;
22289  current_xmachine_household = current_xmachine_household_holder->agent;
22290  current_xmachine_household_next_state = household_HouseholdUpdateDeposits_state;
22291  /* For backwards compatibility set current_xmachine */
22292  current_xmachine->xmachine_firm = NULL;
22293  current_xmachine->xmachine_household = NULL;
22294  current_xmachine->xmachine_equityfund = NULL;
22295  current_xmachine->xmachine_bank = NULL;
22296  current_xmachine->xmachine_government = NULL;
22297  current_xmachine->xmachine_centralbank = NULL;
22298  current_xmachine->xmachine_jpoffice = NULL;
22299  current_xmachine->xmachine_mall = NULL;
22300  current_xmachine->xmachine_reagency = NULL;
22301  current_xmachine->xmachine_household = current_xmachine_household;
22302 
22303 
22304 
22305 
22306 
22307  i = household_housing_debt_writeoff();
22308 
22309 
22310 
22311  if(i == 1)
22312  {
22313  free_household_agent(current_xmachine_household_holder, household_HHHousingWriteOff_state);
22314  }
22315  else
22316  {
22317  transition_household_agent(current_xmachine_household_holder, household_HHHousingWriteOff_state, household_HouseholdUpdateDeposits_state);
22318  }
22319 
22320 
22321  current_xmachine_household = NULL;
22322 
22323  current_xmachine_household_holder = temp_xmachine_household_holder;
22324  }
22325  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_housing_debt_writeoff\n");
22326 
22327  if(FLAME_mortgage_writeoff_message_board_write == 1)
22328  {
22329 
22330  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_mortgage_writeoff)\n");
22331  rc = MB_SyncStart(b_mortgage_writeoff);
22332  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_mortgage_writeoff)\n");
22333  #ifdef ERRCHECK
22334  if (rc != MB_SUCCESS)
22335  {
22336  fprintf(stderr, "ERROR: Could not start sync of 'mortgage_writeoff' board\n");
22337  switch(rc) {
22338  case MB_ERR_INVALID:
22339  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is invalid\n");
22340  break;
22341  case MB_ERR_LOCKED:
22342  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is locked\n");
22343  break;
22344  case MB_ERR_MEMALLOC:
22345  fprintf(stderr, "\t reason: out of memory\n");
22346  break;
22347  case MB_ERR_INTERNAL:
22348  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22349  break;
22350  default:
22351  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
22352  break;
22353  }
22354 
22355 
22356  exit(rc);
22357  }
22358  #endif
22359  }
22360 
22361 
22362 
22363  /* If mb is not read then leave sync complete until last possible moment */
22364  if(FLAME_mortgage_payment_message_board_read == 1)
22365  {
22366  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_payment)\n");
22367  rc = MB_SyncComplete(b_mortgage_payment);
22368  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_payment)\n");
22369  #ifdef ERRCHECK
22370  if (rc != MB_SUCCESS)
22371  {
22372  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_payment' board\n");
22373  switch(rc) {
22374  case MB_ERR_INVALID:
22375  fprintf(stderr, "\t reason: 'mortgage_payment' board is invalid\n");
22376  break;
22377  case MB_ERR_MEMALLOC:
22378  fprintf(stderr, "\t reason: out of memory\n");
22379  break;
22380  case MB_ERR_INTERNAL:
22381  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22382  break;
22383  default:
22384  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
22385  break;
22386  }
22387 
22388 
22389  exit(rc);
22390  }
22391  #endif
22392 
22393 
22394 
22395  }
22396 
22397  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_housing_recieve_mortgages\n");
22398  current_xmachine_bank_holder = bank_BankHousingMortgages_state->agents;
22399  while(current_xmachine_bank_holder)
22400  {
22401  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
22402  current_xmachine_bank = current_xmachine_bank_holder->agent;
22403  current_xmachine_bank_next_state = bank_BankHousingWriteOff_state;
22404  /* For backwards compatibility set current_xmachine */
22405  current_xmachine->xmachine_firm = NULL;
22406  current_xmachine->xmachine_household = NULL;
22407  current_xmachine->xmachine_equityfund = NULL;
22408  current_xmachine->xmachine_bank = NULL;
22409  current_xmachine->xmachine_government = NULL;
22410  current_xmachine->xmachine_centralbank = NULL;
22411  current_xmachine->xmachine_jpoffice = NULL;
22412  current_xmachine->xmachine_mall = NULL;
22413  current_xmachine->xmachine_reagency = NULL;
22414  current_xmachine->xmachine_bank = current_xmachine_bank;
22415 
22416 
22417 
22418 
22419 
22420 
22421 
22422 
22423  rc = MB_Iterator_CreateFiltered(b_mortgage_payment, &i_mortgage_payment, &FLAME_filter_bank_bank_housing_recieve_mortgages_BankHousingMortgages_BankHousingWriteOff_mortgage_payment, current_xmachine_bank);
22424 
22425 
22426 
22427  #ifdef ERRCHECK
22428  if (rc != MB_SUCCESS)
22429  {
22430  fprintf(stderr, "ERROR: Could not create Iterator for 'mortgage_payment'\n");
22431  switch(rc) {
22432  case MB_ERR_INVALID:
22433  fprintf(stderr, "\t reason: 'mortgage_payment' board is invalid\n");
22434  break;
22435  case MB_ERR_LOCKED:
22436  fprintf(stderr, "\t reason: 'mortgage_payment' board is locked\n");
22437  break;
22438  case MB_ERR_MEMALLOC:
22439  fprintf(stderr, "\t reason: out of memory\n");
22440  break;
22441  case MB_ERR_INTERNAL:
22442  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22443  break;
22444  default:
22445 
22446  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
22447 
22448 
22449  break;
22450  }
22451 
22452 
22453  exit(rc);
22454  }
22455  #endif
22456 
22457 
22458 
22459  i = bank_housing_recieve_mortgages();
22460 
22461 
22462  rc = MB_Iterator_Delete(&i_mortgage_payment);
22463  #ifdef ERRCHECK
22464  if (rc != MB_SUCCESS)
22465  {
22466  fprintf(stderr, "ERROR: Could not delete 'mortgage_payment' iterator\n");
22467  switch(rc) {
22468  case MB_ERR_INVALID:
22469  fprintf(stderr, "\t reason: 'mortgage_payment' iterator is invalid\n");
22470  break;
22471  case MB_ERR_INTERNAL:
22472  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22473  break;
22474  default:
22475  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
22476  break;
22477  }
22478 
22479 
22480  exit(rc);
22481  }
22482  #endif
22483 
22484 
22485  if(i == 1)
22486  {
22487  free_bank_agent(current_xmachine_bank_holder, bank_BankHousingMortgages_state);
22488  }
22489  else
22490  {
22491  transition_bank_agent(current_xmachine_bank_holder, bank_BankHousingMortgages_state, bank_BankHousingWriteOff_state);
22492  }
22493 
22494 
22495  current_xmachine_bank = NULL;
22496 
22497  current_xmachine_bank_holder = temp_xmachine_bank_holder;
22498  }
22499  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_housing_recieve_mortgages\n");
22500 
22501 
22502 /* End of layer number 49 */
22503 
22504 /* Clear message boards that have finished being used
22505  * and sync complete if doing late sync complete */
22506 
22507 if(FLAME_mortgage_payment_message_board_read == 0)
22508 {
22509  /*printf("%d> mortgage_payment message board sync complete late as no agents reading any messages of this type\n", node_number);*/
22510 
22511  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_payment)\n");
22512  rc = MB_SyncComplete(b_mortgage_payment);
22513  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_payment)\n");
22514  #ifdef ERRCHECK
22515  if (rc != MB_SUCCESS)
22516  {
22517  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_payment' board\n");
22518  switch(rc) {
22519  case MB_ERR_INVALID:
22520  fprintf(stderr, "\t reason: 'mortgage_payment' board is invalid\n");
22521  break;
22522  case MB_ERR_MEMALLOC:
22523  fprintf(stderr, "\t reason: out of memory\n");
22524  break;
22525  case MB_ERR_INTERNAL:
22526  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22527  break;
22528  default:
22529  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
22530  break;
22531  }
22532 
22533 
22534  exit(rc);
22535  }
22536  #endif
22537 }
22538 
22539  /* Delete any search trees */
22540 
22541  rc = MB_Clear(b_mortgage_payment);
22542  #ifdef ERRCHECK
22543  if (rc != MB_SUCCESS)
22544  {
22545  fprintf(stderr, "ERROR: Could not clear 'mortgage_payment' board\n");
22546  switch(rc) {
22547  case MB_ERR_INVALID:
22548  fprintf(stderr, "\t reason: 'mortgage_payment' board is invalid\n");
22549  break;
22550  case MB_ERR_LOCKED:
22551  fprintf(stderr, "\t reason: 'mortgage_payment' board is locked\n");
22552  break;
22553  case MB_ERR_INTERNAL:
22554  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22555  break;
22556  default:
22557  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
22558  break;
22559 
22560  }
22561 
22562 
22563  exit(rc);
22564  }
22565  #endif
22566 
22567  /* DEBUG: States with branching functions */
22568  current_xmachine_household_holder = household_HouseholdUpdateDeposits_state->agents;
22569  while(current_xmachine_household_holder)
22570  {
22571  FLAME_debug_count = 0;
22572  /* Function: household_update_bank_account */
22573  if(FLAME_condition_household_household_update_bank_account_HouseholdUpdateDeposits_end(current_xmachine_household_holder->agent)==1)
22574  { FLAME_debug_count++; }
22575  /* Function: idle */
22576  if(FLAME_condition_household_idle_HouseholdUpdateDeposits_end(current_xmachine_household_holder->agent)==1)
22577  { FLAME_debug_count++; }
22578  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
22579  if(FLAME_debug_count != 1)
22580  {
22581  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'household' leaving state 'HouseholdUpdateDeposits'\n");
22582  if(FLAME_debug_count > 1)
22583  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
22584  if(FLAME_debug_count == 0)
22585  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
22586  }
22587 
22588  current_xmachine_household_holder = current_xmachine_household_holder->next;
22589  }
22590 
22591  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start household_update_bank_account\n");
22592  current_xmachine_household_holder = household_HouseholdUpdateDeposits_state->agents;
22593  while(current_xmachine_household_holder)
22594  {
22595  temp_xmachine_household_holder = current_xmachine_household_holder->next;
22596  current_xmachine_household = current_xmachine_household_holder->agent;
22597  current_xmachine_household_next_state = household_end_state;
22598  /* For backwards compatibility set current_xmachine */
22599  current_xmachine->xmachine_firm = NULL;
22600  current_xmachine->xmachine_household = NULL;
22601  current_xmachine->xmachine_equityfund = NULL;
22602  current_xmachine->xmachine_bank = NULL;
22603  current_xmachine->xmachine_government = NULL;
22604  current_xmachine->xmachine_centralbank = NULL;
22605  current_xmachine->xmachine_jpoffice = NULL;
22606  current_xmachine->xmachine_mall = NULL;
22607  current_xmachine->xmachine_reagency = NULL;
22608  current_xmachine->xmachine_household = current_xmachine_household;
22609 
22610  if(FLAME_condition_household_household_update_bank_account_HouseholdUpdateDeposits_end(current_xmachine_household)==1)
22611  {
22612 
22613 
22614 
22615  i = household_update_bank_account();
22616 
22617 
22618 
22619  if(i == 1)
22620  {
22621  free_household_agent(current_xmachine_household_holder, household_HouseholdUpdateDeposits_state);
22622  }
22623  else
22624  {
22625  transition_household_agent(current_xmachine_household_holder, household_HouseholdUpdateDeposits_state, household_end_state);
22626  }
22627  }
22628 
22629  current_xmachine_household = NULL;
22630 
22631  current_xmachine_household_holder = temp_xmachine_household_holder;
22632  }
22633  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish household_update_bank_account\n");
22634 
22635  if(FLAME_household_bank_update_deposit_message_board_write == 1)
22636  {
22637 
22638  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncStart(b_household_bank_update_deposit)\n");
22639  rc = MB_SyncStart(b_household_bank_update_deposit);
22640  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finish MB_SyncStart(b_household_bank_update_deposit)\n");
22641  #ifdef ERRCHECK
22642  if (rc != MB_SUCCESS)
22643  {
22644  fprintf(stderr, "ERROR: Could not start sync of 'household_bank_update_deposit' board\n");
22645  switch(rc) {
22646  case MB_ERR_INVALID:
22647  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is invalid\n");
22648  break;
22649  case MB_ERR_LOCKED:
22650  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is locked\n");
22651  break;
22652  case MB_ERR_MEMALLOC:
22653  fprintf(stderr, "\t reason: out of memory\n");
22654  break;
22655  case MB_ERR_INTERNAL:
22656  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22657  break;
22658  default:
22659  fprintf(stderr, "\t MB_SyncStart returned error code: %d (see libmboard docs for details)\n", rc);
22660  break;
22661  }
22662 
22663 
22664  exit(rc);
22665  }
22666  #endif
22667  }
22668 
22669 
22670 
22671  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
22672  current_xmachine_household_holder = household_HouseholdUpdateDeposits_state->agents;
22673  while(current_xmachine_household_holder)
22674  {
22675  temp_xmachine_household_holder = current_xmachine_household_holder->next;
22676  current_xmachine_household = current_xmachine_household_holder->agent;
22677  current_xmachine_household_next_state = household_end_state;
22678  /* For backwards compatibility set current_xmachine */
22679  current_xmachine->xmachine_firm = NULL;
22680  current_xmachine->xmachine_household = NULL;
22681  current_xmachine->xmachine_equityfund = NULL;
22682  current_xmachine->xmachine_bank = NULL;
22683  current_xmachine->xmachine_government = NULL;
22684  current_xmachine->xmachine_centralbank = NULL;
22685  current_xmachine->xmachine_jpoffice = NULL;
22686  current_xmachine->xmachine_mall = NULL;
22687  current_xmachine->xmachine_reagency = NULL;
22688  current_xmachine->xmachine_household = current_xmachine_household;
22689 
22690  if(FLAME_condition_household_idle_HouseholdUpdateDeposits_end(current_xmachine_household)==1)
22691  {
22692 
22693 
22694 
22695  i = idle();
22696 
22697 
22698 
22699  if(i == 1)
22700  {
22701  free_household_agent(current_xmachine_household_holder, household_HouseholdUpdateDeposits_state);
22702  }
22703  else
22704  {
22705  transition_household_agent(current_xmachine_household_holder, household_HouseholdUpdateDeposits_state, household_end_state);
22706  }
22707  }
22708 
22709  current_xmachine_household = NULL;
22710 
22711  current_xmachine_household_holder = temp_xmachine_household_holder;
22712  }
22713  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
22714 
22715 
22716  /* If mb is not read then leave sync complete until last possible moment */
22717  if(FLAME_mortgage_writeoff_message_board_read == 1)
22718  {
22719  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_writeoff)\n");
22720  rc = MB_SyncComplete(b_mortgage_writeoff);
22721  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_writeoff)\n");
22722  #ifdef ERRCHECK
22723  if (rc != MB_SUCCESS)
22724  {
22725  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_writeoff' board\n");
22726  switch(rc) {
22727  case MB_ERR_INVALID:
22728  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is invalid\n");
22729  break;
22730  case MB_ERR_MEMALLOC:
22731  fprintf(stderr, "\t reason: out of memory\n");
22732  break;
22733  case MB_ERR_INTERNAL:
22734  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22735  break;
22736  default:
22737  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
22738  break;
22739  }
22740 
22741 
22742  exit(rc);
22743  }
22744  #endif
22745 
22746 
22747 
22748  }
22749 
22750  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_housing_debt_writeoff\n");
22751  current_xmachine_bank_holder = bank_BankHousingWriteOff_state->agents;
22752  while(current_xmachine_bank_holder)
22753  {
22754  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
22755  current_xmachine_bank = current_xmachine_bank_holder->agent;
22756  current_xmachine_bank_next_state = bank_BankUpdateDeposits_state;
22757  /* For backwards compatibility set current_xmachine */
22758  current_xmachine->xmachine_firm = NULL;
22759  current_xmachine->xmachine_household = NULL;
22760  current_xmachine->xmachine_equityfund = NULL;
22761  current_xmachine->xmachine_bank = NULL;
22762  current_xmachine->xmachine_government = NULL;
22763  current_xmachine->xmachine_centralbank = NULL;
22764  current_xmachine->xmachine_jpoffice = NULL;
22765  current_xmachine->xmachine_mall = NULL;
22766  current_xmachine->xmachine_reagency = NULL;
22767  current_xmachine->xmachine_bank = current_xmachine_bank;
22768 
22769 
22770 
22771 
22772 
22773 
22774 
22775 
22776  rc = MB_Iterator_CreateFiltered(b_mortgage_writeoff, &i_mortgage_writeoff, &FLAME_filter_bank_bank_housing_debt_writeoff_BankHousingWriteOff_BankUpdateDeposits_mortgage_writeoff, current_xmachine_bank);
22777 
22778 
22779 
22780  #ifdef ERRCHECK
22781  if (rc != MB_SUCCESS)
22782  {
22783  fprintf(stderr, "ERROR: Could not create Iterator for 'mortgage_writeoff'\n");
22784  switch(rc) {
22785  case MB_ERR_INVALID:
22786  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is invalid\n");
22787  break;
22788  case MB_ERR_LOCKED:
22789  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is locked\n");
22790  break;
22791  case MB_ERR_MEMALLOC:
22792  fprintf(stderr, "\t reason: out of memory\n");
22793  break;
22794  case MB_ERR_INTERNAL:
22795  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22796  break;
22797  default:
22798 
22799  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
22800 
22801 
22802  break;
22803  }
22804 
22805 
22806  exit(rc);
22807  }
22808  #endif
22809 
22810 
22811 
22812  i = bank_housing_debt_writeoff();
22813 
22814 
22815  rc = MB_Iterator_Delete(&i_mortgage_writeoff);
22816  #ifdef ERRCHECK
22817  if (rc != MB_SUCCESS)
22818  {
22819  fprintf(stderr, "ERROR: Could not delete 'mortgage_writeoff' iterator\n");
22820  switch(rc) {
22821  case MB_ERR_INVALID:
22822  fprintf(stderr, "\t reason: 'mortgage_writeoff' iterator is invalid\n");
22823  break;
22824  case MB_ERR_INTERNAL:
22825  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22826  break;
22827  default:
22828  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
22829  break;
22830  }
22831 
22832 
22833  exit(rc);
22834  }
22835  #endif
22836 
22837 
22838  if(i == 1)
22839  {
22840  free_bank_agent(current_xmachine_bank_holder, bank_BankHousingWriteOff_state);
22841  }
22842  else
22843  {
22844  transition_bank_agent(current_xmachine_bank_holder, bank_BankHousingWriteOff_state, bank_BankUpdateDeposits_state);
22845  }
22846 
22847 
22848  current_xmachine_bank = NULL;
22849 
22850  current_xmachine_bank_holder = temp_xmachine_bank_holder;
22851  }
22852  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_housing_debt_writeoff\n");
22853 
22854 
22855 /* End of layer number 50 */
22856 
22857 /* Clear message boards that have finished being used
22858  * and sync complete if doing late sync complete */
22859 
22860 if(FLAME_mortgage_writeoff_message_board_read == 0)
22861 {
22862  /*printf("%d> mortgage_writeoff message board sync complete late as no agents reading any messages of this type\n", node_number);*/
22863 
22864  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_mortgage_writeoff)\n");
22865  rc = MB_SyncComplete(b_mortgage_writeoff);
22866  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_mortgage_writeoff)\n");
22867  #ifdef ERRCHECK
22868  if (rc != MB_SUCCESS)
22869  {
22870  fprintf(stderr, "ERROR: Could not complete sync of 'mortgage_writeoff' board\n");
22871  switch(rc) {
22872  case MB_ERR_INVALID:
22873  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is invalid\n");
22874  break;
22875  case MB_ERR_MEMALLOC:
22876  fprintf(stderr, "\t reason: out of memory\n");
22877  break;
22878  case MB_ERR_INTERNAL:
22879  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22880  break;
22881  default:
22882  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
22883  break;
22884  }
22885 
22886 
22887  exit(rc);
22888  }
22889  #endif
22890 }
22891 
22892  /* Delete any search trees */
22893 
22894  rc = MB_Clear(b_mortgage_writeoff);
22895  #ifdef ERRCHECK
22896  if (rc != MB_SUCCESS)
22897  {
22898  fprintf(stderr, "ERROR: Could not clear 'mortgage_writeoff' board\n");
22899  switch(rc) {
22900  case MB_ERR_INVALID:
22901  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is invalid\n");
22902  break;
22903  case MB_ERR_LOCKED:
22904  fprintf(stderr, "\t reason: 'mortgage_writeoff' board is locked\n");
22905  break;
22906  case MB_ERR_INTERNAL:
22907  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
22908  break;
22909  default:
22910  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
22911  break;
22912 
22913  }
22914 
22915 
22916  exit(rc);
22917  }
22918  #endif
22919 
22920  /* DEBUG: States with branching functions */
22921  current_xmachine_bank_holder = bank_BankUpdateDeposits_state->agents;
22922  while(current_xmachine_bank_holder)
22923  {
22924  FLAME_debug_count = 0;
22925  /* Function: bank_update_deposits */
22926  if(FLAME_condition_bank_bank_update_deposits_BankUpdateDeposits_end(current_xmachine_bank_holder->agent)==1)
22927  { FLAME_debug_count++; }
22928  /* Function: idle */
22929  if(FLAME_condition_bank_idle_BankUpdateDeposits_end(current_xmachine_bank_holder->agent)==1)
22930  { FLAME_debug_count++; }
22931  /*printf("FLAME_debug_count = %d\n", FLAME_debug_count);*/
22932  if(FLAME_debug_count != 1)
22933  {
22934  fprintf(stderr, "ERROR: A function condition test has failed for agent type 'bank' leaving state 'BankUpdateDeposits'\n");
22935  if(FLAME_debug_count > 1)
22936  fprintf(stderr, "\t reason: there was more than one possible outgoing transition function\n");
22937  if(FLAME_debug_count == 0)
22938  fprintf(stderr, "\t reason: there was no possible outgoing transition function\n");
22939  }
22940 
22941  current_xmachine_bank_holder = current_xmachine_bank_holder->next;
22942  }
22943 
22944  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start idle\n");
22945  current_xmachine_bank_holder = bank_BankUpdateDeposits_state->agents;
22946  while(current_xmachine_bank_holder)
22947  {
22948  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
22949  current_xmachine_bank = current_xmachine_bank_holder->agent;
22950  current_xmachine_bank_next_state = bank_end_state;
22951  /* For backwards compatibility set current_xmachine */
22952  current_xmachine->xmachine_firm = NULL;
22953  current_xmachine->xmachine_household = NULL;
22954  current_xmachine->xmachine_equityfund = NULL;
22955  current_xmachine->xmachine_bank = NULL;
22956  current_xmachine->xmachine_government = NULL;
22957  current_xmachine->xmachine_centralbank = NULL;
22958  current_xmachine->xmachine_jpoffice = NULL;
22959  current_xmachine->xmachine_mall = NULL;
22960  current_xmachine->xmachine_reagency = NULL;
22961  current_xmachine->xmachine_bank = current_xmachine_bank;
22962 
22963  if(FLAME_condition_bank_idle_BankUpdateDeposits_end(current_xmachine_bank)==1)
22964  {
22965 
22966 
22967 
22968  i = idle();
22969 
22970 
22971 
22972  if(i == 1)
22973  {
22974  free_bank_agent(current_xmachine_bank_holder, bank_BankUpdateDeposits_state);
22975  }
22976  else
22977  {
22978  transition_bank_agent(current_xmachine_bank_holder, bank_BankUpdateDeposits_state, bank_end_state);
22979  }
22980  }
22981 
22982  current_xmachine_bank = NULL;
22983 
22984  current_xmachine_bank_holder = temp_xmachine_bank_holder;
22985  }
22986  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish idle\n");
22987 
22988 
22989  /* If mb is not read then leave sync complete until last possible moment */
22990  if(FLAME_household_bank_update_deposit_message_board_read == 1)
22991  {
22992  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_household_bank_update_deposit)\n");
22993  rc = MB_SyncComplete(b_household_bank_update_deposit);
22994  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_household_bank_update_deposit)\n");
22995  #ifdef ERRCHECK
22996  if (rc != MB_SUCCESS)
22997  {
22998  fprintf(stderr, "ERROR: Could not complete sync of 'household_bank_update_deposit' board\n");
22999  switch(rc) {
23000  case MB_ERR_INVALID:
23001  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is invalid\n");
23002  break;
23003  case MB_ERR_MEMALLOC:
23004  fprintf(stderr, "\t reason: out of memory\n");
23005  break;
23006  case MB_ERR_INTERNAL:
23007  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23008  break;
23009  default:
23010  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
23011  break;
23012  }
23013 
23014 
23015  exit(rc);
23016  }
23017  #endif
23018 
23019 
23020 
23021  }
23022 
23023  /* If mb is not read then leave sync complete until last possible moment */
23024  if(FLAME_firm_bank_update_deposit_message_board_read == 1)
23025  {
23026  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_firm_bank_update_deposit)\n");
23027  rc = MB_SyncComplete(b_firm_bank_update_deposit);
23028  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_firm_bank_update_deposit)\n");
23029  #ifdef ERRCHECK
23030  if (rc != MB_SUCCESS)
23031  {
23032  fprintf(stderr, "ERROR: Could not complete sync of 'firm_bank_update_deposit' board\n");
23033  switch(rc) {
23034  case MB_ERR_INVALID:
23035  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is invalid\n");
23036  break;
23037  case MB_ERR_MEMALLOC:
23038  fprintf(stderr, "\t reason: out of memory\n");
23039  break;
23040  case MB_ERR_INTERNAL:
23041  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23042  break;
23043  default:
23044  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
23045  break;
23046  }
23047 
23048 
23049  exit(rc);
23050  }
23051  #endif
23052 
23053 
23054 
23055  }
23056 
23057  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("start bank_update_deposits\n");
23058  current_xmachine_bank_holder = bank_BankUpdateDeposits_state->agents;
23059  while(current_xmachine_bank_holder)
23060  {
23061  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
23062  current_xmachine_bank = current_xmachine_bank_holder->agent;
23063  current_xmachine_bank_next_state = bank_end_state;
23064  /* For backwards compatibility set current_xmachine */
23065  current_xmachine->xmachine_firm = NULL;
23066  current_xmachine->xmachine_household = NULL;
23067  current_xmachine->xmachine_equityfund = NULL;
23068  current_xmachine->xmachine_bank = NULL;
23069  current_xmachine->xmachine_government = NULL;
23070  current_xmachine->xmachine_centralbank = NULL;
23071  current_xmachine->xmachine_jpoffice = NULL;
23072  current_xmachine->xmachine_mall = NULL;
23073  current_xmachine->xmachine_reagency = NULL;
23074  current_xmachine->xmachine_bank = current_xmachine_bank;
23075 
23076  if(FLAME_condition_bank_bank_update_deposits_BankUpdateDeposits_end(current_xmachine_bank)==1)
23077  {
23078 
23079 
23080 
23081 
23082 
23083 
23084  rc = MB_Iterator_CreateFiltered(b_household_bank_update_deposit, &i_household_bank_update_deposit, &FLAME_filter_bank_bank_update_deposits_BankUpdateDeposits_end_household_bank_update_deposit, current_xmachine_bank);
23085 
23086 
23087 
23088  #ifdef ERRCHECK
23089  if (rc != MB_SUCCESS)
23090  {
23091  fprintf(stderr, "ERROR: Could not create Iterator for 'household_bank_update_deposit'\n");
23092  switch(rc) {
23093  case MB_ERR_INVALID:
23094  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is invalid\n");
23095  break;
23096  case MB_ERR_LOCKED:
23097  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is locked\n");
23098  break;
23099  case MB_ERR_MEMALLOC:
23100  fprintf(stderr, "\t reason: out of memory\n");
23101  break;
23102  case MB_ERR_INTERNAL:
23103  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23104  break;
23105  default:
23106 
23107  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
23108 
23109 
23110  break;
23111  }
23112 
23113 
23114  exit(rc);
23115  }
23116  #endif
23117 
23118 
23119 
23120 
23121 
23122 
23123  rc = MB_Iterator_CreateFiltered(b_firm_bank_update_deposit, &i_firm_bank_update_deposit, &FLAME_filter_bank_bank_update_deposits_BankUpdateDeposits_end_firm_bank_update_deposit, current_xmachine_bank);
23124 
23125 
23126 
23127  #ifdef ERRCHECK
23128  if (rc != MB_SUCCESS)
23129  {
23130  fprintf(stderr, "ERROR: Could not create Iterator for 'firm_bank_update_deposit'\n");
23131  switch(rc) {
23132  case MB_ERR_INVALID:
23133  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is invalid\n");
23134  break;
23135  case MB_ERR_LOCKED:
23136  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is locked\n");
23137  break;
23138  case MB_ERR_MEMALLOC:
23139  fprintf(stderr, "\t reason: out of memory\n");
23140  break;
23141  case MB_ERR_INTERNAL:
23142  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23143  break;
23144  default:
23145 
23146  fprintf(stderr, "\t MB_Iterator_CreateFiltered returned error code: %d (see libmboard docs for details)\n", rc);
23147 
23148 
23149  break;
23150  }
23151 
23152 
23153  exit(rc);
23154  }
23155  #endif
23156 
23157 
23158 
23159  i = bank_update_deposits();
23160 
23161 
23162  rc = MB_Iterator_Delete(&i_household_bank_update_deposit);
23163  #ifdef ERRCHECK
23164  if (rc != MB_SUCCESS)
23165  {
23166  fprintf(stderr, "ERROR: Could not delete 'household_bank_update_deposit' iterator\n");
23167  switch(rc) {
23168  case MB_ERR_INVALID:
23169  fprintf(stderr, "\t reason: 'household_bank_update_deposit' iterator is invalid\n");
23170  break;
23171  case MB_ERR_INTERNAL:
23172  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23173  break;
23174  default:
23175  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
23176  break;
23177  }
23178 
23179 
23180  exit(rc);
23181  }
23182  #endif
23183 
23184  rc = MB_Iterator_Delete(&i_firm_bank_update_deposit);
23185  #ifdef ERRCHECK
23186  if (rc != MB_SUCCESS)
23187  {
23188  fprintf(stderr, "ERROR: Could not delete 'firm_bank_update_deposit' iterator\n");
23189  switch(rc) {
23190  case MB_ERR_INVALID:
23191  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' iterator is invalid\n");
23192  break;
23193  case MB_ERR_INTERNAL:
23194  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23195  break;
23196  default:
23197  fprintf(stderr, "\t MB_Iterator_Delete returned error code: %d (see libmboard docs for details)\n", rc);
23198  break;
23199  }
23200 
23201 
23202  exit(rc);
23203  }
23204  #endif
23205 
23206 
23207  if(i == 1)
23208  {
23209  free_bank_agent(current_xmachine_bank_holder, bank_BankUpdateDeposits_state);
23210  }
23211  else
23212  {
23213  transition_bank_agent(current_xmachine_bank_holder, bank_BankUpdateDeposits_state, bank_end_state);
23214  }
23215  }
23216 
23217  current_xmachine_bank = NULL;
23218 
23219  current_xmachine_bank_holder = temp_xmachine_bank_holder;
23220  }
23221  if(FLAME_TEST_PRINT_START_AND_END_OF_MODEL_FUNCTIONS) printf("finish bank_update_deposits\n");
23222 
23223 
23224 /* End of layer number 51 */
23225 
23226 /* Clear message boards that have finished being used
23227  * and sync complete if doing late sync complete */
23228 
23229 if(FLAME_firm_bank_update_deposit_message_board_read == 0)
23230 {
23231  /*printf("%d> firm_bank_update_deposit message board sync complete late as no agents reading any messages of this type\n", node_number);*/
23232 
23233  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_firm_bank_update_deposit)\n");
23234  rc = MB_SyncComplete(b_firm_bank_update_deposit);
23235  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_firm_bank_update_deposit)\n");
23236  #ifdef ERRCHECK
23237  if (rc != MB_SUCCESS)
23238  {
23239  fprintf(stderr, "ERROR: Could not complete sync of 'firm_bank_update_deposit' board\n");
23240  switch(rc) {
23241  case MB_ERR_INVALID:
23242  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is invalid\n");
23243  break;
23244  case MB_ERR_MEMALLOC:
23245  fprintf(stderr, "\t reason: out of memory\n");
23246  break;
23247  case MB_ERR_INTERNAL:
23248  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23249  break;
23250  default:
23251  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
23252  break;
23253  }
23254 
23255 
23256  exit(rc);
23257  }
23258  #endif
23259 }
23260 
23261  /* Delete any search trees */
23262 
23263  rc = MB_Clear(b_firm_bank_update_deposit);
23264  #ifdef ERRCHECK
23265  if (rc != MB_SUCCESS)
23266  {
23267  fprintf(stderr, "ERROR: Could not clear 'firm_bank_update_deposit' board\n");
23268  switch(rc) {
23269  case MB_ERR_INVALID:
23270  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is invalid\n");
23271  break;
23272  case MB_ERR_LOCKED:
23273  fprintf(stderr, "\t reason: 'firm_bank_update_deposit' board is locked\n");
23274  break;
23275  case MB_ERR_INTERNAL:
23276  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23277  break;
23278  default:
23279  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
23280  break;
23281 
23282  }
23283 
23284 
23285  exit(rc);
23286  }
23287  #endif
23288 
23289 if(FLAME_household_bank_update_deposit_message_board_read == 0)
23290 {
23291  /*printf("%d> household_bank_update_deposit message board sync complete late as no agents reading any messages of this type\n", node_number);*/
23292 
23293  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("start MB_SyncComplete(b_household_bank_update_deposit)\n");
23294  rc = MB_SyncComplete(b_household_bank_update_deposit);
23295  if(FLAME_TEST_PRINT_START_AND_END_OF_LIBMBOARD_CALLS) printf("finsh MB_SyncComplete(b_household_bank_update_deposit)\n");
23296  #ifdef ERRCHECK
23297  if (rc != MB_SUCCESS)
23298  {
23299  fprintf(stderr, "ERROR: Could not complete sync of 'household_bank_update_deposit' board\n");
23300  switch(rc) {
23301  case MB_ERR_INVALID:
23302  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is invalid\n");
23303  break;
23304  case MB_ERR_MEMALLOC:
23305  fprintf(stderr, "\t reason: out of memory\n");
23306  break;
23307  case MB_ERR_INTERNAL:
23308  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23309  break;
23310  default:
23311  fprintf(stderr, "\t MB_SyncComplete returned error code: %d (see libmboard docs for details)\n", rc);
23312  break;
23313  }
23314 
23315 
23316  exit(rc);
23317  }
23318  #endif
23319 }
23320 
23321  /* Delete any search trees */
23322 
23323  rc = MB_Clear(b_household_bank_update_deposit);
23324  #ifdef ERRCHECK
23325  if (rc != MB_SUCCESS)
23326  {
23327  fprintf(stderr, "ERROR: Could not clear 'household_bank_update_deposit' board\n");
23328  switch(rc) {
23329  case MB_ERR_INVALID:
23330  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is invalid\n");
23331  break;
23332  case MB_ERR_LOCKED:
23333  fprintf(stderr, "\t reason: 'household_bank_update_deposit' board is locked\n");
23334  break;
23335  case MB_ERR_INTERNAL:
23336  fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
23337  break;
23338  default:
23339  fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
23340  break;
23341 
23342  }
23343 
23344 
23345  exit(rc);
23346  }
23347  #endif
23348 
23349 
23350 
23351  /*printf("firm_FirmHousingPrice_state->count = %d\n", firm_FirmHousingPrice_state->count);*/
23352  firm_FirmHousingPrice_state->count = 0;
23353 
23354  /*printf("firm_FirmHousingSell_state->count = %d\n", firm_FirmHousingSell_state->count);*/
23355  firm_FirmHousingSell_state->count = 0;
23356 
23357  /*printf("firm_FirmHousingMarket_state->count = %d\n", firm_FirmHousingMarket_state->count);*/
23358  firm_FirmHousingMarket_state->count = 0;
23359 
23360  /*printf("firm_FirmCreditInsolvencyCheck_state->count = %d\n", firm_FirmCreditInsolvencyCheck_state->count);*/
23361  firm_FirmCreditInsolvencyCheck_state->count = 0;
23362 
23363  /*printf("firm_FirmCreditCheckTaxRate_state->count = %d\n", firm_FirmCreditCheckTaxRate_state->count);*/
23364  firm_FirmCreditCheckTaxRate_state->count = 0;
23365 
23366  /*printf("firm_FirmCreditCheckInterestRate_state->count = %d\n", firm_FirmCreditCheckInterestRate_state->count);*/
23367  firm_FirmCreditCheckInterestRate_state->count = 0;
23368 
23369  /*printf("firm_FirmCreditDividendPayments_state->count = %d\n", firm_FirmCreditDividendPayments_state->count);*/
23370  firm_FirmCreditDividendPayments_state->count = 0;
23371 
23372  /*printf("firm_FirmCreditBalanceSheet_state->count = %d\n", firm_FirmCreditBalanceSheet_state->count);*/
23373  firm_FirmCreditBalanceSheet_state->count = 0;
23374 
23375  /*printf("firm_FirmCreditBankruptcy_state->count = %d\n", firm_FirmCreditBankruptcy_state->count);*/
23376  firm_FirmCreditBankruptcy_state->count = 0;
23377 
23378  /*printf("firm_FirmCreditLiquidityRecheck_state->count = %d\n", firm_FirmCreditLiquidityRecheck_state->count);*/
23379  firm_FirmCreditLiquidityRecheck_state->count = 0;
23380 
23381  /*printf("firm_FirmCreditIlliquidityStatus_state->count = %d\n", firm_FirmCreditIlliquidityStatus_state->count);*/
23382  firm_FirmCreditIlliquidityStatus_state->count = 0;
23383 
23384  /*printf("firm_FirmCreditLoanBorrow2_state->count = %d\n", firm_FirmCreditLoanBorrow2_state->count);*/
23385  firm_FirmCreditLoanBorrow2_state->count = 0;
23386 
23387  /*printf("firm_FirmCreditLoanBorrow1_state->count = %d\n", firm_FirmCreditLoanBorrow1_state->count);*/
23388  firm_FirmCreditLoanBorrow1_state->count = 0;
23389 
23390  /*printf("firm_FirmCreditPayments_state->count = %d\n", firm_FirmCreditPayments_state->count);*/
23391  firm_FirmCreditPayments_state->count = 0;
23392 
23393  /*printf("firm_FirmCreditStatus_state->count = %d\n", firm_FirmCreditStatus_state->count);*/
23394  firm_FirmCreditStatus_state->count = 0;
23395 
23396  /*printf("firm_FirmCreditLiquidityNeed_state->count = %d\n", firm_FirmCreditLiquidityNeed_state->count);*/
23397  firm_FirmCreditLiquidityNeed_state->count = 0;
23398 
23399  /*printf("firm_FirmCreditComputeDividends_state->count = %d\n", firm_FirmCreditComputeDividends_state->count);*/
23400  firm_FirmCreditComputeDividends_state->count = 0;
23401 
23402  /*printf("firm_FirmCreditInvestment_state->count = %d\n", firm_FirmCreditInvestment_state->count);*/
23403  firm_FirmCreditInvestment_state->count = 0;
23404 
23405  /*printf("firm_FirmConstructionLabourDemand_state->count = %d\n", firm_FirmConstructionLabourDemand_state->count);*/
23406  firm_FirmConstructionLabourDemand_state->count = 0;
23407 
23408  /*printf("firm_FirmProductionLabourDemand_state->count = %d\n", firm_FirmProductionLabourDemand_state->count);*/
23409  firm_FirmProductionLabourDemand_state->count = 0;
23410 
23411  /*printf("firm_FirmProductionPlanning_state->count = %d\n", firm_FirmProductionPlanning_state->count);*/
23412  firm_FirmProductionPlanning_state->count = 0;
23413 
23414  /*printf("firm_FirmProductionConstructor_state->count = %d\n", firm_FirmProductionConstructor_state->count);*/
23415  firm_FirmProductionConstructor_state->count = 0;
23416 
23417  /*printf("firm_FirmProductionRegular_state->count = %d\n", firm_FirmProductionRegular_state->count);*/
23418  firm_FirmProductionRegular_state->count = 0;
23419 
23420  /*printf("firm_FirmProductionRoleCheck_state->count = %d\n", firm_FirmProductionRoleCheck_state->count);*/
23421  firm_FirmProductionRoleCheck_state->count = 0;
23422 
23423  /*printf("firm_FirmProductionSkip_state->count = %d\n", firm_FirmProductionSkip_state->count);*/
23424  firm_FirmProductionSkip_state->count = 0;
23425 
23426  /*printf("firm_FirmProductionStart_state->count = %d\n", firm_FirmProductionStart_state->count);*/
23427  firm_FirmProductionStart_state->count = 0;
23428 
23429  /*printf("firm_FirmLabourWageAdjustment_state->count = %d\n", firm_FirmLabourWageAdjustment_state->count);*/
23430  firm_FirmLabourWageAdjustment_state->count = 0;
23431 
23432  /*printf("firm_FirmLabourStage2End_state->count = %d\n", firm_FirmLabourStage2End_state->count);*/
23433  firm_FirmLabourStage2End_state->count = 0;
23434 
23435  /*printf("firm_FirmLabourStage2_state->count = %d\n", firm_FirmLabourStage2_state->count);*/
23436  firm_FirmLabourStage2_state->count = 0;
23437 
23438  /*printf("firm_FirmLabourStage1Application_state->count = %d\n", firm_FirmLabourStage1Application_state->count);*/
23439  firm_FirmLabourStage1Application_state->count = 0;
23440 
23441  /*printf("firm_FirmLabourStage1End_state->count = %d\n", firm_FirmLabourStage1End_state->count);*/
23442  firm_FirmLabourStage1End_state->count = 0;
23443 
23444  /*printf("firm_FirmLabourStage1_state->count = %d\n", firm_FirmLabourStage1_state->count);*/
23445  firm_FirmLabourStage1_state->count = 0;
23446 
23447  /*printf("firm_FirmLabourPayWages_state->count = %d\n", firm_FirmLabourPayWages_state->count);*/
23448  firm_FirmLabourPayWages_state->count = 0;
23449 
23450  /*printf("firm_FirmLabourStart_state->count = %d\n", firm_FirmLabourStart_state->count);*/
23451  firm_FirmLabourStart_state->count = 0;
23452 
23453  /*printf("firm_FirmConsumptionPrice_state->count = %d\n", firm_FirmConsumptionPrice_state->count);*/
23454  firm_FirmConsumptionPrice_state->count = 0;
23455 
23456  /*printf("firm_FirmRecieveSales_state->count = %d\n", firm_FirmRecieveSales_state->count);*/
23457  firm_FirmRecieveSales_state->count = 0;
23458 
23459  /*printf("firm_FirmHousingStart_state->count = %d\n", firm_FirmHousingStart_state->count);*/
23460  firm_FirmHousingStart_state->count = 0;
23461 
23462  /*printf("firm_FirmConsumptionStart_state->count = %d\n", firm_FirmConsumptionStart_state->count);*/
23463  firm_FirmConsumptionStart_state->count = 0;
23464 
23465  /*printf("firm_end_state->count = %d\n", firm_end_state->count);*/
23466  firm_end_state->count = 0;
23467 
23468  /*printf("firm_FirmUpdateDeposits_state->count = %d\n", firm_FirmUpdateDeposits_state->count);*/
23469  firm_FirmUpdateDeposits_state->count = 0;
23470 
23471  /*printf("firm_FirmCreditStart_state->count = %d\n", firm_FirmCreditStart_state->count);*/
23472  firm_FirmCreditStart_state->count = 0;
23473 
23474  /*printf("firm_start_state->count = %d\n", firm_start_state->count);*/
23475  firm_start_state->count = 0;
23476 
23477  /*printf("household_HHHousingWriteOff_state->count = %d\n", household_HHHousingWriteOff_state->count);*/
23478  household_HHHousingWriteOff_state->count = 0;
23479 
23480  /*printf("household_HHHousingPayments_state->count = %d\n", household_HHHousingPayments_state->count);*/
23481  household_HHHousingPayments_state->count = 0;
23482 
23483  /*printf("household_HHHousingBargain_state->count = %d\n", household_HHHousingBargain_state->count);*/
23484  household_HHHousingBargain_state->count = 0;
23485 
23486  /*printf("household_HHHousingRevenue_state->count = %d\n", household_HHHousingRevenue_state->count);*/
23487  household_HHHousingRevenue_state->count = 0;
23488 
23489  /*printf("household_HHHousingCheckWealth_state->count = %d\n", household_HHHousingCheckWealth_state->count);*/
23490  household_HHHousingCheckWealth_state->count = 0;
23491 
23492  /*printf("household_HHHousingPrice_state->count = %d\n", household_HHHousingPrice_state->count);*/
23493  household_HHHousingPrice_state->count = 0;
23494 
23495  /*printf("household_HHHousingRole_state->count = %d\n", household_HHHousingRole_state->count);*/
23496  household_HHHousingRole_state->count = 0;
23497 
23498  /*printf("household_HHCreditEmployment_state->count = %d\n", household_HHCreditEmployment_state->count);*/
23499  household_HHCreditEmployment_state->count = 0;
23500 
23501  /*printf("household_HHCreditCheckTaxRate_state->count = %d\n", household_HHCreditCheckTaxRate_state->count);*/
23502  household_HHCreditCheckTaxRate_state->count = 0;
23503 
23504  /*printf("household_HHCreditCheckInterestRate_state->count = %d\n", household_HHCreditCheckInterestRate_state->count);*/
23505  household_HHCreditCheckInterestRate_state->count = 0;
23506 
23507  /*printf("household_HHCreditBalanceSheet_state->count = %d\n", household_HHCreditBalanceSheet_state->count);*/
23508  household_HHCreditBalanceSheet_state->count = 0;
23509 
23510  /*printf("household_HHCreditIsCapitalist_state->count = %d\n", household_HHCreditIsCapitalist_state->count);*/
23511  household_HHCreditIsCapitalist_state->count = 0;
23512 
23513  /*printf("household_HHCreditMonthly_state->count = %d\n", household_HHCreditMonthly_state->count);*/
23514  household_HHCreditMonthly_state->count = 0;
23515 
23516  /*printf("household_HHLabourPayroll_state->count = %d\n", household_HHLabourPayroll_state->count);*/
23517  household_HHLabourPayroll_state->count = 0;
23518 
23519  /*printf("household_HHLabourStage1Placement_state->count = %d\n", household_HHLabourStage1Placement_state->count);*/
23520  household_HHLabourStage1Placement_state->count = 0;
23521 
23522  /*printf("household_HHLabourStage1Applications_state->count = %d\n", household_HHLabourStage1Applications_state->count);*/
23523  household_HHLabourStage1Applications_state->count = 0;
23524 
23525  /*printf("household_HHLabourStage2_state->count = %d\n", household_HHLabourStage2_state->count);*/
23526  household_HHLabourStage2_state->count = 0;
23527 
23528  /*printf("household_HHLabourStage1_state->count = %d\n", household_HHLabourStage1_state->count);*/
23529  household_HHLabourStage1_state->count = 0;
23530 
23531  /*printf("household_HHLabourEmploymentStatus_state->count = %d\n", household_HHLabourEmploymentStatus_state->count);*/
23532  household_HHLabourEmploymentStatus_state->count = 0;
23533 
23534  /*printf("household_HHLabourStart_state->count = %d\n", household_HHLabourStart_state->count);*/
23535  household_HHLabourStart_state->count = 0;
23536 
23537  /*printf("household_HHConsumptionRecieveGoods_state->count = %d\n", household_HHConsumptionRecieveGoods_state->count);*/
23538  household_HHConsumptionRecieveGoods_state->count = 0;
23539 
23540  /*printf("household_HHHousingStart_state->count = %d\n", household_HHHousingStart_state->count);*/
23541  household_HHHousingStart_state->count = 0;
23542 
23543  /*printf("household_HHConsumptionWeekly_state->count = %d\n", household_HHConsumptionWeekly_state->count);*/
23544  household_HHConsumptionWeekly_state->count = 0;
23545 
23546  /*printf("household_HHConsumptionStart_state->count = %d\n", household_HHConsumptionStart_state->count);*/
23547  household_HHConsumptionStart_state->count = 0;
23548 
23549  /*printf("household_end_state->count = %d\n", household_end_state->count);*/
23550  household_end_state->count = 0;
23551 
23552  /*printf("household_HouseholdUpdateDeposits_state->count = %d\n", household_HouseholdUpdateDeposits_state->count);*/
23553  household_HouseholdUpdateDeposits_state->count = 0;
23554 
23555  /*printf("household_HHCreditStart_state->count = %d\n", household_HHCreditStart_state->count);*/
23556  household_HHCreditStart_state->count = 0;
23557 
23558  /*printf("household_start_state->count = %d\n", household_start_state->count);*/
23559  household_start_state->count = 0;
23560 
23561  /*printf("equityfund_EFCreditCheckTaxRate_state->count = %d\n", equityfund_EFCreditCheckTaxRate_state->count);*/
23562  equityfund_EFCreditCheckTaxRate_state->count = 0;
23563 
23564  /*printf("equityfund_EFCreditBalanceSheet_state->count = %d\n", equityfund_EFCreditBalanceSheet_state->count);*/
23565  equityfund_EFCreditBalanceSheet_state->count = 0;
23566 
23567  /*printf("equityfund_EFCreditShareCollectionFirms_state->count = %d\n", equityfund_EFCreditShareCollectionFirms_state->count);*/
23568  equityfund_EFCreditShareCollectionFirms_state->count = 0;
23569 
23570  /*printf("equityfund_EFCreditShareCollectionBanks_state->count = %d\n", equityfund_EFCreditShareCollectionBanks_state->count);*/
23571  equityfund_EFCreditShareCollectionBanks_state->count = 0;
23572 
23573  /*printf("equityfund_EFCreditDistributeShares_state->count = %d\n", equityfund_EFCreditDistributeShares_state->count);*/
23574  equityfund_EFCreditDistributeShares_state->count = 0;
23575 
23576  /*printf("equityfund_end_state->count = %d\n", equityfund_end_state->count);*/
23577  equityfund_end_state->count = 0;
23578 
23579  /*printf("equityfund_EFLabourMarket_state->count = %d\n", equityfund_EFLabourMarket_state->count);*/
23580  equityfund_EFLabourMarket_state->count = 0;
23581 
23582  /*printf("equityfund_EquityFundStart_state->count = %d\n", equityfund_EquityFundStart_state->count);*/
23583  equityfund_EquityFundStart_state->count = 0;
23584 
23585  /*printf("equityfund_start_state->count = %d\n", equityfund_start_state->count);*/
23586  equityfund_start_state->count = 0;
23587 
23588  /*printf("bank_BankHousingWriteOff_state->count = %d\n", bank_BankHousingWriteOff_state->count);*/
23589  bank_BankHousingWriteOff_state->count = 0;
23590 
23591  /*printf("bank_BankHousingMortgages_state->count = %d\n", bank_BankHousingMortgages_state->count);*/
23592  bank_BankHousingMortgages_state->count = 0;
23593 
23594  /*printf("bank_BankHousingSales_state->count = %d\n", bank_BankHousingSales_state->count);*/
23595  bank_BankHousingSales_state->count = 0;
23596 
23597  /*printf("bank_BankHousingCrediting_state->count = %d\n", bank_BankHousingCrediting_state->count);*/
23598  bank_BankHousingCrediting_state->count = 0;
23599 
23600  /*printf("bank_BankCreditCheckInterestRate_state->count = %d\n", bank_BankCreditCheckInterestRate_state->count);*/
23601  bank_BankCreditCheckInterestRate_state->count = 0;
23602 
23603  /*printf("bank_BankCreditLoanInterests_state->count = %d\n", bank_BankCreditLoanInterests_state->count);*/
23604  bank_BankCreditLoanInterests_state->count = 0;
23605 
23606  /*printf("bank_BankCreditNewEntrants_state->count = %d\n", bank_BankCreditNewEntrants_state->count);*/
23607  bank_BankCreditNewEntrants_state->count = 0;
23608 
23609  /*printf("bank_BankCreditLoanWriteOffs_state->count = %d\n", bank_BankCreditLoanWriteOffs_state->count);*/
23610  bank_BankCreditLoanWriteOffs_state->count = 0;
23611 
23612  /*printf("bank_BankCreditRequest2_state->count = %d\n", bank_BankCreditRequest2_state->count);*/
23613  bank_BankCreditRequest2_state->count = 0;
23614 
23615  /*printf("bank_BankCreditRequest1_state->count = %d\n", bank_BankCreditRequest1_state->count);*/
23616  bank_BankCreditRequest1_state->count = 0;
23617 
23618  /*printf("bank_BankCreditBalanceSheet_state->count = %d\n", bank_BankCreditBalanceSheet_state->count);*/
23619  bank_BankCreditBalanceSheet_state->count = 0;
23620 
23621  /*printf("bank_BankCreditDividends_state->count = %d\n", bank_BankCreditDividends_state->count);*/
23622  bank_BankCreditDividends_state->count = 0;
23623 
23624  /*printf("bank_BankHousingMarket_state->count = %d\n", bank_BankHousingMarket_state->count);*/
23625  bank_BankHousingMarket_state->count = 0;
23626 
23627  /*printf("bank_end_state->count = %d\n", bank_end_state->count);*/
23628  bank_end_state->count = 0;
23629 
23630  /*printf("bank_BankUpdateDeposits_state->count = %d\n", bank_BankUpdateDeposits_state->count);*/
23631  bank_BankUpdateDeposits_state->count = 0;
23632 
23633  /*printf("bank_BankCreditStart_state->count = %d\n", bank_BankCreditStart_state->count);*/
23634  bank_BankCreditStart_state->count = 0;
23635 
23636  /*printf("bank_start_state->count = %d\n", bank_start_state->count);*/
23637  bank_start_state->count = 0;
23638 
23639  /*printf("government_GovernmentLabourTax_state->count = %d\n", government_GovernmentLabourTax_state->count);*/
23640  government_GovernmentLabourTax_state->count = 0;
23641 
23642  /*printf("government_GovernmentUnemploymentBenefits_state->count = %d\n", government_GovernmentUnemploymentBenefits_state->count);*/
23643  government_GovernmentUnemploymentBenefits_state->count = 0;
23644 
23645  /*printf("government_GovernmentFiscalPolicy_state->count = %d\n", government_GovernmentFiscalPolicy_state->count);*/
23646  government_GovernmentFiscalPolicy_state->count = 0;
23647 
23648  /*printf("government_GovernmentBalanceSheet_state->count = %d\n", government_GovernmentBalanceSheet_state->count);*/
23649  government_GovernmentBalanceSheet_state->count = 0;
23650 
23651  /*printf("government_GovernmentIncomeStatement_state->count = %d\n", government_GovernmentIncomeStatement_state->count);*/
23652  government_GovernmentIncomeStatement_state->count = 0;
23653 
23654  /*printf("government_GovernmentCentralbankProfits_state->count = %d\n", government_GovernmentCentralbankProfits_state->count);*/
23655  government_GovernmentCentralbankProfits_state->count = 0;
23656 
23657  /*printf("government_GovernmentMonthly_state->count = %d\n", government_GovernmentMonthly_state->count);*/
23658  government_GovernmentMonthly_state->count = 0;
23659 
23660  /*printf("government_end_state->count = %d\n", government_end_state->count);*/
23661  government_end_state->count = 0;
23662 
23663  /*printf("government_GovernmentLabourStatus_state->count = %d\n", government_GovernmentLabourStatus_state->count);*/
23664  government_GovernmentLabourStatus_state->count = 0;
23665 
23666  /*printf("government_GovernmentStart_state->count = %d\n", government_GovernmentStart_state->count);*/
23667  government_GovernmentStart_state->count = 0;
23668 
23669  /*printf("government_start_state->count = %d\n", government_start_state->count);*/
23670  government_start_state->count = 0;
23671 
23672  /*printf("centralbank_end_state->count = %d\n", centralbank_end_state->count);*/
23673  centralbank_end_state->count = 0;
23674 
23675  /*printf("centralbank_CentralBankInterestRate_state->count = %d\n", centralbank_CentralBankInterestRate_state->count);*/
23676  centralbank_CentralBankInterestRate_state->count = 0;
23677 
23678  /*printf("centralbank_CentralBankBalanceSheet_state->count = %d\n", centralbank_CentralBankBalanceSheet_state->count);*/
23679  centralbank_CentralBankBalanceSheet_state->count = 0;
23680 
23681  /*printf("centralbank_CentralBankIncomeStatement_state->count = %d\n", centralbank_CentralBankIncomeStatement_state->count);*/
23682  centralbank_CentralBankIncomeStatement_state->count = 0;
23683 
23684  /*printf("centralbank_CentralBankDebtRequests_state->count = %d\n", centralbank_CentralBankDebtRequests_state->count);*/
23685  centralbank_CentralBankDebtRequests_state->count = 0;
23686 
23687  /*printf("centralbank_CentralBankLabour_state->count = %d\n", centralbank_CentralBankLabour_state->count);*/
23688  centralbank_CentralBankLabour_state->count = 0;
23689 
23690  /*printf("centralbank_CentralBankHousing_state->count = %d\n", centralbank_CentralBankHousing_state->count);*/
23691  centralbank_CentralBankHousing_state->count = 0;
23692 
23693  /*printf("centralbank_CentralBankConsumption_state->count = %d\n", centralbank_CentralBankConsumption_state->count);*/
23694  centralbank_CentralBankConsumption_state->count = 0;
23695 
23696  /*printf("centralbank_CentralBankCredit_state->count = %d\n", centralbank_CentralBankCredit_state->count);*/
23697  centralbank_CentralBankCredit_state->count = 0;
23698 
23699  /*printf("centralbank_start_state->count = %d\n", centralbank_start_state->count);*/
23700  centralbank_start_state->count = 0;
23701 
23702  /*printf("jpoffice_JPOLabourStage2_state->count = %d\n", jpoffice_JPOLabourStage2_state->count);*/
23703  jpoffice_JPOLabourStage2_state->count = 0;
23704 
23705  /*printf("jpoffice_end_state->count = %d\n", jpoffice_end_state->count);*/
23706  jpoffice_end_state->count = 0;
23707 
23708  /*printf("jpoffice_JPOLabourMarket_state->count = %d\n", jpoffice_JPOLabourMarket_state->count);*/
23709  jpoffice_JPOLabourMarket_state->count = 0;
23710 
23711  /*printf("jpoffice_start_state->count = %d\n", jpoffice_start_state->count);*/
23712  jpoffice_start_state->count = 0;
23713 
23714  /*printf("mall_MallConsumptionSummary_state->count = %d\n", mall_MallConsumptionSummary_state->count);*/
23715  mall_MallConsumptionSummary_state->count = 0;
23716 
23717  /*printf("mall_end_state->count = %d\n", mall_end_state->count);*/
23718  mall_end_state->count = 0;
23719 
23720  /*printf("mall_MallConsumptionMarket_state->count = %d\n", mall_MallConsumptionMarket_state->count);*/
23721  mall_MallConsumptionMarket_state->count = 0;
23722 
23723  /*printf("mall_start_state->count = %d\n", mall_start_state->count);*/
23724  mall_start_state->count = 0;
23725 
23726  /*printf("reagency_REAgencyHousingSummary_state->count = %d\n", reagency_REAgencyHousingSummary_state->count);*/
23727  reagency_REAgencyHousingSummary_state->count = 0;
23728 
23729  /*printf("reagency_REAgencyHousingProcess_state->count = %d\n", reagency_REAgencyHousingProcess_state->count);*/
23730  reagency_REAgencyHousingProcess_state->count = 0;
23731 
23732  /*printf("reagency_end_state->count = %d\n", reagency_end_state->count);*/
23733  reagency_end_state->count = 0;
23734 
23735  /*printf("reagency_REAgencyHousingMarket_state->count = %d\n", reagency_REAgencyHousingMarket_state->count);*/
23736  reagency_REAgencyHousingMarket_state->count = 0;
23737 
23738  /*printf("reagency_start_state->count = %d\n", reagency_start_state->count);*/
23739  reagency_start_state->count = 0;
23740 
23741  /* Move agents to their start states */
23742 
23743  current_xmachine_firm_holder = firm_end_state->agents;
23744  while(current_xmachine_firm_holder)
23745  {
23746  temp_xmachine_firm_holder = current_xmachine_firm_holder->next;
23747  transition_firm_agent(current_xmachine_firm_holder, firm_end_state, firm_start_state);
23748 
23749  current_xmachine_firm_holder = temp_xmachine_firm_holder;
23750  }
23751 
23752  current_xmachine_household_holder = household_end_state->agents;
23753  while(current_xmachine_household_holder)
23754  {
23755  temp_xmachine_household_holder = current_xmachine_household_holder->next;
23756  transition_household_agent(current_xmachine_household_holder, household_end_state, household_start_state);
23757 
23758  current_xmachine_household_holder = temp_xmachine_household_holder;
23759  }
23760 
23761  current_xmachine_equityfund_holder = equityfund_end_state->agents;
23762  while(current_xmachine_equityfund_holder)
23763  {
23764  temp_xmachine_equityfund_holder = current_xmachine_equityfund_holder->next;
23765  transition_equityfund_agent(current_xmachine_equityfund_holder, equityfund_end_state, equityfund_start_state);
23766 
23767  current_xmachine_equityfund_holder = temp_xmachine_equityfund_holder;
23768  }
23769 
23770  current_xmachine_bank_holder = bank_end_state->agents;
23771  while(current_xmachine_bank_holder)
23772  {
23773  temp_xmachine_bank_holder = current_xmachine_bank_holder->next;
23774  transition_bank_agent(current_xmachine_bank_holder, bank_end_state, bank_start_state);
23775 
23776  current_xmachine_bank_holder = temp_xmachine_bank_holder;
23777  }
23778 
23779  current_xmachine_government_holder = government_end_state->agents;
23780  while(current_xmachine_government_holder)
23781  {
23782  temp_xmachine_government_holder = current_xmachine_government_holder->next;
23783  transition_government_agent(current_xmachine_government_holder, government_end_state, government_start_state);
23784 
23785  current_xmachine_government_holder = temp_xmachine_government_holder;
23786  }
23787 
23788  current_xmachine_centralbank_holder = centralbank_end_state->agents;
23789  while(current_xmachine_centralbank_holder)
23790  {
23791  temp_xmachine_centralbank_holder = current_xmachine_centralbank_holder->next;
23792  transition_centralbank_agent(current_xmachine_centralbank_holder, centralbank_end_state, centralbank_start_state);
23793 
23794  current_xmachine_centralbank_holder = temp_xmachine_centralbank_holder;
23795  }
23796 
23797  current_xmachine_jpoffice_holder = jpoffice_end_state->agents;
23798  while(current_xmachine_jpoffice_holder)
23799  {
23800  temp_xmachine_jpoffice_holder = current_xmachine_jpoffice_holder->next;
23801  transition_jpoffice_agent(current_xmachine_jpoffice_holder, jpoffice_end_state, jpoffice_start_state);
23802 
23803  current_xmachine_jpoffice_holder = temp_xmachine_jpoffice_holder;
23804  }
23805 
23806  current_xmachine_mall_holder = mall_end_state->agents;
23807  while(current_xmachine_mall_holder)
23808  {
23809  temp_xmachine_mall_holder = current_xmachine_mall_holder->next;
23810  transition_mall_agent(current_xmachine_mall_holder, mall_end_state, mall_start_state);
23811 
23812  current_xmachine_mall_holder = temp_xmachine_mall_holder;
23813  }
23814 
23815  current_xmachine_reagency_holder = reagency_end_state->agents;
23816  while(current_xmachine_reagency_holder)
23817  {
23818  temp_xmachine_reagency_holder = current_xmachine_reagency_holder->next;
23819  transition_reagency_agent(current_xmachine_reagency_holder, reagency_end_state, reagency_start_state);
23820 
23821  current_xmachine_reagency_holder = temp_xmachine_reagency_holder;
23822  }
23823 
23824  if(iteration_loop%output_frequency == output_offset)
23825  {
23826  saveiterationdata(iteration_loop);
23827  }
23828 
23829  /* Calculate if any agents need to jump S.P. */
23830  /* propagate_agents(); */
23831  /* Save iteration time to log file */
23832 
23833  if((file = fopen(logfilepath, "a"))==NULL)
23834  {
23835  printf("Error: cannot open file '%s' for writing\n", logfilepath);
23836  exit(0);
23837  }
23838  (void)fputs("<iteration><no>", file);
23839  sprintf(data, "%i", iteration_loop);
23840  (void)fputs(data, file);
23841  (void)fputs("</no><time>", file);
23842  sprintf(data, "%d", (int)((get_time() - interval) * 1000) );
23843  (void)fputs(data, file);
23844  (void)fputs("</time></iteration>\n", file);
23845  (void)fclose(file);
23846 
23847  }
23848 
23849 
23850 
23851  /* Stop timing and print total time */
23852  stop = get_time();
23853  total_time = stop - start;
23854  printf("Execution time - %d:%02d:%03d [mins:secs:msecs]\n",
23855  (int)(total_time/60), ((int)total_time)%60, (((int)(total_time * 1000.0)) % 1000));
23856 
23857  clean_up(0);
23858 
23859  /* Exit successfully by returning zero to Operating System */
23860  return 0;
23861 }
Generated on Sat Sep 7 2013 17:40:38 for ICEACE by   doxygen 1.8.3.1